743. 网络延迟时间 --迪杰斯特拉算法 （最短路劲）

743. 网络延迟时间
     有 N 个网络节点，标记为 1 到 N。

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

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

示例：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], N = 4, K = 2
输出：2

注意:

N 的范围在 [1, 100] 之间。
K 的范围在 [1, N] 之间。
times 的长度在 [1, 6000] 之间。
所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。

本算法的主要步骤：1. 对信息进行处理 设置 distance 数组，graph数组等
2.在一个for循环找出当前距离 k节点 最近的点作为跳板 ，将其设置为已加入 ，重新更新 图的 distance 数据 当该循环结束后，代表已经加入了N-1 个跳板 迪杰斯特拉算法的步骤已经完成
3.返回最大值即可

class Solution {
    public int networkDelayTime(int[][] times, int N, int K) {
        // 建立一个 二维数组 存储 图的 每一个节点 的信息  graph[i][j] 代表 i到j 的距离
        int [][] graph = new int[N+1][N+1];
        // 初始化，设置距离为-1
        for(int i=0; i<N+1 ;i++){
            for(int j=0 ;j<N+1;j++){
                graph[i][j]=-1;
            }
        }
        //将times中的数据提出 times[0] 代表第一条边 times[0][0] 代表起点 times[0][1] 重点 times[0][2] 时间
        for(int i=0;i< times.length;i++){
            graph[times[i][0]][times[i][1]] = times[i][2];    
        }
        // distance[j] 代表 K 到j的距离,顺带初始化 
        int [] distance = new int [N+1];

          for (int i = 1; i <= N; i++) {
            distance[i] = graph[K][i];
        }
        distance[K]=0;

            // 判断是否找到K到达该点最短路径
        boolean[] visited = new boolean[N + 1];
        //k节点自己不能作为跳板
        visited[K] = true;
        
        //开始遍历
        for(int i=1 ;i<N;i++){
            int minDistance = 99999;
            int minIndex = 1;
            //找到距离k最近的节点 (即找跳板) 
            for(int j=1;j<N+1 ;j++){
                //这里注意 当前要加入的跳板必须是未访问过的节点 不然会重复添加跳板
                if(distance[j]!= -1 && distance[j] < minDistance && j!= K && !visited[j]){
                  minIndex = j;
                  minDistance= distance[j];
                }
            }
            //标志当前最近的点已经找到 
            visited[minIndex]=true;
            //通过当前找到的最近点 ，将其作为跳板 更新到其他点的距离
            for(int j=1;j<N+1;j++){
                if(graph[minIndex][j] != -1 ){
                    //这步寓意何为？ 判断 这个 j节点是否已经能到达 k节点 若可以则比较 若不可以，直接赋值
                    if(distance[j]!=-1){
                       distance[j]= Math.min(distance[j] ,  graph[minIndex][j]+ minDistance );
                    }else{
                        distance[j] = minDistance+graph[minIndex][j];
                    }
                }
            }
        }
        //上述的第一个for循环 就表示已经添加了 n-1 个跳板  若此时 还有distance =-1 说明不连通 
        int maxDistance = 0;
        //找到最大的返回
          for (int i = 1; i <= N; i++) {
            if (distance[i] == -1) {
                return -1;
            }
            maxDistance = Math.max(distance[i], maxDistance);
        }

        return maxDistance;







    }
}