3112. Minimum Time to Visit Disappearing Nodes

C++

class Solution {
public:
    vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {
        vector<int> dist(n, -1);
        vector<bool> visited(n, false);

        vector<unordered_map<int, set<int, less<int>>>> map(n);
        for (auto const& e : edges) {
            if (e[0] == e[1]) continue;
            map[e[0]][e[1]].insert(e[2]);
            map[e[1]][e[0]].insert(e[2]);
        }

        // pair<dist: int, node: int>
        priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;

        pq.push({0, 0});
        dist[0] = 0;
        while (!pq.empty()) {
            auto top = pq.top();
            pq.pop();
            const int cur_dist = top.first;
            const int cur = top.second;

            if (visited[cur] || dist[cur] == -1) continue;
            visited[cur] = true;

            for (auto const& map_n : map[cur]) {
                const int i = map_n.first; // The node links to cur
                const int new_dist = *map_n.second.begin() + dist[cur];
                if (new_dist < disappear[i] && (dist[i] == -1 || dist[i] > new_dist)) {
                    dist[i] = new_dist;
                    pq.push({new_dist, i});
                }
            }
        }

        return dist;
    }
};