LeetCode.743 每日一题｜ 8月更文挑战743. 网络延迟时间有 n 个网络节点，标记为 1 到 n。给你

743. 网络延迟时间

有 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：

首先根据题目中给出的信息，建图，这里使用数组模拟邻接表来建图；模板如下：

    void add(int a, int b, int c) {
        w[idx] = c; e[idx] = b; ne[idx] = h[a]; h[a] = idx ++;
    }

其中`w`存边的权重，`e`存下一个节点，`ne`存下一条边，`h`为顶点表；

2. 利用迪杰斯特拉算法，求得源点k距离每个顶点的最短距离；如果存在一个节点，由源点k无法到达的，那么返回-1，否则，返回顶点最短距离中的最大值，即为答案；

迪杰斯特拉算法核心：

1、当到一个时间点时，图上部分的点的最短距离已确定，部分点的最短距离未确定。

2、选一个所有未确定点中离源点最近的点，把他认为成最短距离。

3、再把这个点所有出边遍历一边，更新所有的点。

具体实现代码：

class Solution {

    int N = 110, M = 6010;
    boolean[] st;
    int[] dist;
    int[] h = new int[N], ne = new int[M], w = new int[M], e = new int[M];
    int res = 0, idx = 0;
    
    
    void add(int a, int b, int c) {
        w[idx] = c; e[idx] = b; ne[idx] = h[a]; h[a] = idx ++;
    }

    public int networkDelayTime(int[][] times, int n, int k) {
        //初始化
        st = new boolean[n + 1];
        dist = new int[n + 1];
        for (int i = 0; i <= n; i ++ ) {
            h[i] = -1;
            dist[i] = 110;
        }
        //建图
        for (int[] t : times) 
            add(t[0], t[1], t[2]);
        //起点距离设为0
        dist[k] = 0;
        Dijkstra(k);
        //找最短距离中的最大值
        for (int i = 1; i <= n; i ++ )
            res = Math.max(res, dist[i]);
        //存在某点无法到达
        if (res > 100) return -1;
        return res;
    }

    void Dijkstra(int u) {
        //定义小根堆
        PriorityQueue<int[]> heap = new PriorityQueue(new Comparator<int[]>(){
            public int compare(int[] a, int[] b) {
                return a[0] - b[0];
            }
        });
        //起点入堆
        heap.offer(new int[]{0, u});
        while(heap.size() > 0) {
            int[] t = heap.poll();
            int d = t[0], ver = t[1];
            //st[ver]为true，说明之前已经用ver的最短距离来更新过其他点，此时出来的不是最短距离，跳过
            if (st[ver]) continue;
            st[ver] = true;
            for (int i = h[ver]; i != -1; i = ne[i]) {
                int j = e[i];
                //可以更新最短距离
                if (d + w[i] < dist[j]) {
                    dist[j] = d + w[i];
                    heap.offer(new int[]{dist[j], j});
                }
            }
        }
    }
}

在Java中小根堆的定义如下：

    PriorityQueue<int[]> heap = new PriorityQueue(new Comparator<int[]>(){
        public int compare(int[] a, int[] b) {
            return a[0] - b[0];
        }
    });

时间复杂度： O(mlogn)

空间复杂度： O(n)

值得注意的是，由于本题边数远大于点数，是一张稠密图，因此在运行时间上，枚举写法要略快于堆的写法。