LeetCode 743. Network Delay Time(Dijistra算法)

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.

Example 1:
Input: times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2
Output: 2

Note:

N will be in the range [1, 100].
K will be in the range [1, N].
The length of times will be in the range [1, 6000].
All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 0 <= w <= 100.

整体的思路比较好理解，但是有些细节还是要注意：比如，什么时候应该标记为visited，什么时候应该判断visited并continue。关键点在于用一个pq来记录所有的下一层节点，然后每次处理路径最短的那个节点。只有当本节点的所有孩子都加进了pq, 此节点才算被访问过。如果此节点已经被访问过，还是会有可能再次甚至多次见到此节点，这时候就可以直接跳过，因为它已经被更短的路径走过了，之后再走都只会更长，不会是答案了。

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        HashSet<Integer> set = new HashSet<>();
        Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
        for (int i = 0; i < times.length; i++) {
            if (!map.containsKey(times[i][0])) map.put(times[i][0], new HashMap<>());
            map.get(times[i][0]).put(times[i][1],times[i][2]);
        }
        //bfs
        int res = 0;
        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> (o1[0] - o2[0]));
        pq.offer(new int[]{0, k});
        while (!pq.isEmpty()) {
            int[] cur = pq.poll();
            int len = cur[0];
            int node = cur[1];
            if (set.contains(node)) continue;
            set.add(node);
            res = len;
            if (set.size() == n) break;
            if (!map.containsKey(node)) {
                continue;
            }
            Map<Integer, Integer> m = map.get(node);
            for (Integer i : m.keySet()) {
                if (set.contains(i)) continue;
                pq.offer(new int[]{len + m.get(i), i});
            }
        }
        return set.size() == n ? res : -1;
    }
}