题目地址(743. 网络延迟时间)

https://leetcode-cn.com/problems/network-delay-time/

有 n 个网络节点，标记为 1 到 n。

给你一个列表 times，表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点， wi 是一个信号从源节点传递到目标节点的时间。

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。

 

示例 1：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2


示例 2：

输入：times = [[1,2,1]], n = 2, k = 1
输出：1


示例 3：

输入：times = [[1,2,1]], n = 2, k = 2
输出：-1


 

提示：

1 <= k <= n <= 100
1 <= times.length <= 6000
times[i].length == 3
1 <= ui, vi <= n
ui != vi
0 <= wi <= 100
所有 (ui, vi) 对都 互不相同（即，不含重复边）

• dijkstra，循环更新 图

• 语言支持：Java

Java Code:

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        List[] graph = new LinkedList[n+1];
        for(int i = 1;i <=n ;i++ ){
            graph[i] = new LinkedList();
        }
        for(int[] edge : times){
            graph[edge[0]].add(new int[]{edge[1],edge[2]});
        }
        
        int[] distTo = dijkstra(k, graph);

        int res = 0;
        for (int i = 1; i < distTo.length; i++) {
            if (distTo[i] == Integer.MAX_VALUE) {
                return -1;  // 有节点不可达，返回 -1
            }
            res = Math.max(res, distTo[i]);
        }
        return res;
    }
    int[] dijkstra(int start, List[] graph) {
        int[] distTo = new int[graph.length];
        Arrays.fill(distTo,Integer.MAX_VALUE);
        distTo[start] = 0;

        Queue pq = new PriorityQueue<>((a,b)-> a.dist - b.dist); // 优先遍历 最短的路线
        pq.offer(new State(start,0));
        while(!pq.isEmpty()){
            State curState = pq.poll();
            int curNodeID = curState.id;
            int curDist = curState.dist;
            if (curDist > distTo[curNodeID]) {
                continue;
            }
            for(int[] item : graph[curNodeID]){
                int nextId = item[0];
                int nextItemDist = distTo[curNodeID] + item[1];
                if(distTo[nextId] > nextItemDist ){ //存在更短的路径， 会循环更新
                    distTo[nextId] = nextItemDist;
                    pq.offer(new State(nextId, nextItemDist)); 
                }
            }
        }
        return distTo;
    }
}
class State {
    int id;  // 图节点的 id
    int dist;  // 从 start 节点到当前节点的距离
    State(int id, int distFromStart) {
        this.id = id;
        this.dist = distFromStart;
    }
}