Leetcode.743. 网络延迟时间---Floyd算法/Dijkstra算法---转化为最短路径问题求解

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) 对都 互不相同（即，不含重复边）

题解：

方法一：Floyd算法

这题首先第一时间想到的算法就是DFS，通过将每一种方式都计算出来判断是否可以，但发现不仅计算量巨大且十分不好操作，这里我们可以使用Floyd（弗洛伊德）算法来解决。
首先先简要介绍一下Folyd算法，我们可以通过王卓老师一个视频来简单理解一下最短路径3–Floyd算法。

• 我们首先理解一下题目，题目要我们求的是从k点出发，所有点都被访问到的最短时间，那么我们发现这个问题可以转换一下，即可以变换为从k点出发，到其他点x的最短路径的最大值问题。

明白上述题目转换后，我们就可以使用求解最短路径的Floyd算法进行求解。

• 我们首先通过一个邻接矩阵matrix来存储各个点之间的关系，matrix[u][v] = w表示从u点到v点的最短距离w。我们先将该邻接矩阵初始化，即按照对角线上元素值为0，其他元素值为无穷大进行初始化。接着使用邻接矩阵保存times数组的数据，这样我们的第一步就完成了。
• 接着我们将得到的邻接矩阵过一遍Folyd算法即可得到我们想要的矩阵，此时矩阵里面存储的数值都已经是最短路径，因此通过Floyd算法也是可以求得任意两点之间的最短距离。而此时我们想要的是从k点到其他点x的最短路径的最大值，因此我们遍历点x，找到最大值的matrix[k][x]即可。

本来应该是求从k点出发，刚好激活所有点出来的时间，但是这里由于我们将时间变化为了路径问题，此时我们是不知道谁是最后一个出来的点，而我们存储的又是各个点之间距离的最小值，因此要想知道哪个点是最后出来的点，只要看他的路径值是否最大即可，因为最后一个出来的点时间最大对应到路径上也是最大的。

• 在遍历的同时，还要判断一下邻接矩阵中是否存在从k点出发到不了的点，即是否存在matrix[k][x]为无穷值，如果存在则代表至少有一点我们无法到达，则此时不满足题意，返回-1即可。

这里需要注意我们不能在以后的算法题中尽量使用0x3f3f3f3f作为我们的无穷大，而不是使用Integer.MAX_VALUE，因为：

在算法竞赛中，我们常常需要用到设置一个常量用来代表“无穷大”。
比如对于int类型的数，有的人会采用INT_MAX，即0x7fffffff作为无穷大。但是以INT_MAX为无穷大常常面临一个问题，即加一个其他的数会溢出。
而这种情况在动态规划，或者其他一些递推的算法中常常出现，很有可能导致算法出问题。
所以在算法竞赛中，我们常采用0x3f3f3f3f来作为无穷大。0x3f3f3f3f主要有如下好处：
0x3f3f3f3f的十进制为1061109567，和INT_MAX一个数量级，即10^{9数量级，而一般场合下的数据都是小于10}9的。
0x3f3f3f3f * 2 = 2122219134，无穷大相加依然不会溢出。
可以使用memset(array, 0x3f, sizeof(array))来为数组设初值为0x3f3f3f3f，因为这个数的每个字节都是0x3f。

代码：

class Solution {
    int N = 200;
    int[][] matrix = new int[N][N];
    int maxValue = 0x3f3f3f3f;
    public int networkDelayTime(int[][] times, int n, int k) {
       for(int i=1;i<=n;i++){
           for(int j=1;j<=n;j++){
                if(i==j){
                    matrix[i][j] = 0;
                }
                else{
                    matrix[i][j] = maxValue;
                }
           }
       }

       for(int i=0;i<times.length;i++){
           int u = times[i][0];
           int v = times[i][1];
           int w = times[i][2];
           matrix[u][v] = w;
       }

       floyd(n);
       int res = 0;
       for(int i=1;i<=n;i++){
           if(matrix[k][i]==maxValue){
               return -1;
           }
           res = Math.max(res,matrix[k][i]);
       }

       return res;
    }

    public void floyd(int n){
        for(int m=1;m<=n;m++){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    matrix[i][j] = Math.min(matrix[i][j],matrix[i][m]+matrix[m][j]);
                }
            }
        }
    } 

}

方法二：Dijkstra算法

Dijkstra算法是用来求单源最短路的算法，根据题意，我们将k点作为源点，使用 Dijkstra 算法我们可以得到从源点 k 到其他点 x 的最短距离，再从所有最短路中取 max即可。

代码：

class Solution {
    int N = 200;
    int[][] w = new int[N][N];
    int[] dist = new int[N];
    boolean[] vis = new boolean[N];
    int INF = 0x3f3f3f3f;
    public int networkDelayTime(int[][] times, int n, int k) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if(i==j){
                    w[i][j] = 0;
                }
                else{
                    w[i][j] = INF;
                }
            }
        }
        for (int[] t : times) {
            int u = t[0], v = t[1], c = t[2];
            w[u][v] = c;
        }
        dijkstra(n,k);
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            if(dist[i]==INF){
                return -1;
            }
            ans = Math.max(ans, dist[i]);
        }
        return ans;
    }
    void dijkstra(int n , int k) {
        Arrays.fill(vis, false);
        Arrays.fill(dist, INF);
        dist[k] = 0;
        for (int p = 1; p <= n; p++) {
            int t = -1;
            for (int i = 1; i <= n; i++) {
                if (!vis[i] && (t == -1 || dist[i] < dist[t])) t = i;
            }
            vis[t] = true;
            for (int i = 1; i <= n; i++) {
                dist[i] = Math.min(dist[i], dist[t] + w[t][i]);
            }
        }
    }
}