有 N 个网络节点，标记为 1 到 N。

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

现在，我们向当前的节点 K 发送了一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1。

注意:

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

思路:要使得所有节点都收到信号,只需要找到源点到所有其他点最小距离的最大值即可,
单源最短路径问题,直接套Dijkstra模板就可以

class Solution {
     int [] dis;
    boolean [] visited;
    int map[][];


    public int networkDelayTime(int[][] times, int N, int K) {
        dis = new  int[N+1];
        map = new int[N+1][N+1];

        
        for(int i=1;i<=N;i++){
            for(int j=1;j<=N;j++){
                map[i][j] = Integer.MAX_VALUE;
            }
        }
        
        for(int[] e:times){
            map[e[0]][e[1]]=e[2];
        }

        for(int i=0;i<=N;i++){
            map[i][i] = 0;
        }






        // int result = -1;
        int max = -1;
        dijkstra(map,K,N);



        for(int i=1;i<=N;i++){
            int temp = dis[i];
            max = Math.max(temp,max);
        }

        if (max==Integer.MAX_VALUE){
            return -1;
        }

        return max;
    }

    void dijkstra(int[][]map,int x,int N){

        visited = new boolean[N+1];
        for(int i=1;i<=N;i++){
            dis[i] = Integer.MAX_VALUE;
        }

        dis[x] = 0;



        for(int i=1;i<=N;i++){

            //寻找最短距离
            int min = Integer.MAX_VALUE;
            int u = -1;



            for(int j=1;j<=N;j++){
                if(!visited[j]&&dis[j] < min){
                    min = dis[j];
                    u = j;
                }
            }

            if(u==-1){
                return;
            }

            visited[u] = true;

            //更新其他节点

            for(int v=1;v<=N;v++){
                if(map[u][v]!=Integer.MAX_VALUE && !visited[v]&&dis[v] > dis[u] + map[u][v]){
                    dis[v] = dis[u] + map[u][v];
                }
            }

        }



    }
}