LeetCode 743. 网络延迟时间（迪杰斯特拉）

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

其中： Arrays.fill(distance, -1);是对进行数组进行填充，这里意思是将distance数组全部填充为-1.
迪杰斯特拉：以实例1为例子

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

进行赋值操作后matrix[i][j]=maxValue，matrix数组中得所有值都为int maxValue=100000，再根据已知条件进行填充matrix[time[0]][time[1]]=time[2];，填充后除了matrix[2][1]=1,matrix[2][3]=1,matrix[3][4]=1外，其余得值都为maxValue。
其中 int[] distance = new int[N + 1];，distance[]数组是用来表示某个点到已知点k的距离，例如distance[1]=1,就表示已知点k到点1的最短距离为1.
distance[K]=0;就表示k点到自己的距离为0.
之后进行最核心的操作

 for(int i=1;i<=N-1;i++){
            int min=Integer.MAX_VALUE;
            int index=-1;
            //选择当前最短得路径
            for(int j=1;j<=N;j++){
                if(!visited[j] && matrix[K][j]<min){
                    min=matrix[K][j];
                    index=j;
                }
            }
            distance[index]=min;
            visited[index]=true;
            //更新从index出发，到集合上所有顶点得最短路径
             for(int k=1;k<=N;k++){
                if(!visited[k] && matrix[K][index]+matrix[index][k]<matrix[K][k]){
                    matrix[K][k]=matrix[K][index]+matrix[index][k];
                }
            }
        }

此处是 distance[index]=min;的输出结果，

可以看到只有distance[4]的值是由于进入了if的判断而改变了的。注意：if中大写K是表示已知点，小写k是表示循环到的节点。

if(!visited[k] && matrix[K][index]+matrix[index][k]<matrix[K][k]){
                    matrix[K][k]=matrix[K][index]+matrix[index][k];
                }

当index=3，min=1时进入第二个for循环，此时的只有visited[4]是false，matrix[K][index]+matrix[index][k]<matrix[K][k])的表达是：matrix[2][3]+matrix[3][4]<matrix[2][4])，1+1<maxValue(100000),所以满足if条件，进行改变matrix[K][k]=matrix[K][index]+matrix[index][k]，即为matrix[2][4]=matrix[2][3]+matrix[3][4]，所以matrix[2][4]=2.
再进行最后/遍历最大值，如果有节点未被访问，返回 -1，否则返回最大最短路径。

class Solution {
    public static int maxValue=100000;
    public int networkDelayTime(int[][] times, int N, int K) {
        //构建邻接表，用于存放各个点到各个点的距离
        int[][] matrix=new int[N+1][N+1];
        for(int i=0;i<=N;i++){
            for(int j=0;j<=N;j++){
                matrix[i][j]=maxValue;
            }
        }
        //遍历times填充邻接表
        for(int[] time:times)
             matrix[time[0]][time[1]]=time[2];
        //存放 K 到各个点的最短路径，最大的那个最短路径即为结果
        int[] distance = new int[N + 1];
        //Arrays.fill(distance, -1);
        distance[K]=0;
        //判断是否找到K到达该点最短路径
        boolean[] visited = new boolean[N + 1];
        visited[K] = true;
        for(int i=1;i<=N-1;i++){
            int min=Integer.MAX_VALUE;
            int index=-1;
            //选择当前最短得路径
            for(int j=1;j<=N;j++){
                if(!visited[j] && matrix[K][j]<min){
                    min=matrix[K][j];
                    index=j;
                }
            }
            distance[index]=min;
            visited[index]=true;
            //更新从index出发，到集合上所有顶点得最短路径
             for(int k=1;k<=N;k++){
                if(!visited[k] && matrix[K][index]+matrix[index][k]<matrix[K][k]){
                    matrix[K][k]=matrix[K][index]+matrix[index][k];
                }
            }
        }
         int maxDistance = 0;
        // 遍历最大值，如果有节点未被访问，返回 -1，否则返回最大最短路径
        for (int i = 1; i <= N; i++) {
            if (distance[i] ==maxValue) {
                return -1;
            }
            maxDistance = Math.max(distance[i], maxDistance);
        }

        return maxDistance;
    }

}