leetcode——743.网络延迟时间

private final static int MAXVALUE = 1000;
    public int networkDelayTime(int[][] times, int N, int K) {
        boolean[] visited = new boolean[N+1];

        int[][] time = new int[N+1][N+1];
        //在更新时间之前，要先把每一个路径上的时间都初始化为MAXVALUE
        for(int[] row:time){
            //如何填充整个数组的值来着？？？？
            Arrays.fill(row,MAXVALUE);
        }
        for(int i = 0;i<times.length;i++){
            time[times[i][0]][times[i][1]] = times[i][2];      //邻接矩阵更新完毕
        }
        //接下来就是更新并寻找最短路径了
        int minIndex = K;
        visited[K] = true;
        int[] path = new int[N+1];
        for(int i = 1;i<N+1;i++){
            path[i]  = time[K][i];//存储K点到其他个点的距离，即time[K][i]
        }
        path[K] = 0;
        for(int i = 1;i<N+1;i++){
            int min = MAXVALUE;
            for(int j = 1;j<N+1;j++){
                if(!visited[j] && path[j]<min){
                    min = path[j];
                    minIndex = j;
                }
            }
            visited[minIndex] = true;
            for(int j = 1;j<N+1;j++){
                if(!visited[j] && (min + time[minIndex][j] < path[j])){
                    path[j] = min + time[minIndex][j];
                }
            }
        }
        int dis = 0;
        for(int i = 1;i<N+1;i++){
            if(path[i] == MAXVALUE){
                return -1;
            }
            dis = Math.max(dis,path[i]);
        }
        return dis;
    }

我还是一时没反应过来应该用迪杰斯特拉算法求最短路径的，看了别人的答案然后自己又写了一遍，好歹算是顺利，对迪杰斯特拉算法的理解又更加深了一次……

——2020.6.18