图最短路径算法《Floyd，Dijkstra》

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

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

//Floyd：对于每一个顶点k，检查dist(i,k)+dist(k,j) < dist(i,j);是否成立
// 邻接矩阵存储边信息: weight[i][j] = w;
class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        int[][] map = new int[n+1][n+1];
        int max = Integer.MAX_VALUE;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i==j){
    //因为map[3][3] = Math.min(map[3][3],map[3][2]+map[2][3]); 这样会使得map[3][3]的值更新，但是这样是不合法的！！
                    map[i][i] = 0;  
                }else{
                    map[i][j] = max/2;
                }
            }

        }
        for(int[] time:times){
            map[time[0]][time[1]] = time[2];
        }
//--------------------------------以上和Dijkstra算法一致--------------------------------
        
        //初始化完成之后
        // floyd 基本流程为三层循环：  遍历每一个跳板来更新这个二维数组dp
        // 枚举中转点 -> 枚举起点 -> 枚举终点 -> 松弛操作    
        for(int p=1;p<=n;p++){   
            for(int i=1;i<=n;i++){
                for(int j=1;j<=n;j++){
                    map[i][j] = Math.min(map[i][j],map[i][p]+map[p][j]);
                }
            }
        }
        int res = 0;
        for(int i=1;i<=n;i++){
            res = Math.max(res,map[k][i]);
        }
        return (res == max/2) ? -1 : res;
    }
}

---

//Dijkstra算法
class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        final int distance = Integer.MAX_VALUE>>1;
        //graph初始化,邻接矩阵存储
        int[][] graph = new int[n+1][n+1];
        for(int i=0;i<=n;i++){
            Arrays.fill(graph[i],distance);  //权值距离先置为无限大
        }
        for(int i=0;i<=n;i++){
            graph[i][i] = 0;     //自己到自己为0
        }
        //按题目已知初始化
        int len = times.length;
        for(int i=0;i<len;i++){
            int[] cur = times[i];
            graph[cur[0]][cur[1]] = cur[2];
        }
 //--------------------------------以上和Floyd算法一致--------------------------------
        //起点为1开始
        int[] dist = new int[n+1];
        boolean[] visited = new boolean[n+1];
        Arrays.fill(dist,distance);  //dist[i] ：表示k->i的距离
        dist[k] = 0;  //自己到自己为0
        for(int c=0;c<n;c++){
            //找dist最小的值
            int index = -1;
            int minVal = distance;
            for(int i=1;i<=n;i++){
                if(!visited[i]){
                    if(minVal>dist[i]){
                        index = i;
                        minVal = dist[i];
                    }
                }
            }
            if(index==-1){  //出度为0直接return -1;
                return -1;
            }
            //找到了最小的，对最小的graph这一行进行展开 【出度扫描】
            visited[index] = true;
            for(int j=1;j<=n;j++){
                //dist[index]+graph[index][j]：表示能通过该最短路径作为跳板来找到dist[j]的最短路径
                //不难看出只要是graph[index][j]不等于无穷大那么就一定存在值
                dist[j] = Math.min(dist[j],dist[index]+graph[index][j]);
            }
        }
        int res = -1;
        for(int i=1;i<=n;i++){
            res = Math.max(res,dist[i]);
        }
        return res;
    }
}