LeetCode 743. 网络延迟时间

Dj算法 注意这个不是最小生成树 而是判断到达每个点的最小值中的最大值 ，用的应该是dj，最后遍历一遍dis数组
注意dj的一些判断条件：
1.退出条件 visited全部为true
2.判断到达不到全部的定点：
这个比较难判断，我是这么判断的，进行多轮判断后，dis数组一定不包含无穷（就是9999），如果包含无穷，就说明有点到达不到；也就是说 判断dis这个数组中的最小值时不能让index（代码中设置为N-1，为了不让下标越界，实际上这个index设置为无穷更好理解）为默认值。

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Description 我们写代码，靠的是技术（狗头）
 * @auther admin
 * @create 2020-06-24 17:13
 */
public class Solution743 {
    /**
     * dij求单源最短路
     * @param times
     * @param N
     * @param K
     * @return
     */
    int[] dis;
    boolean[] visited;
    int[][] map;
    public int networkDelayTime(int[][] times, int N, int K) {
        /**
         * 保存到已经遍历的顶点的最短路劲
         */
         dis = new int[N];
        /**
         * 记录前驱
         */
         dis =new int[N];
        /**
         * 判断这个顶点是否被访问过
         */
        visited = new boolean[N];
        map = new int[N][N];
        /**
         * paths dis visited初始化
         */
        for (int i = 0;i<N;i++){
            for(int j = 0;j<N;j++)
            {
                if(i==j)map[i][j] = 0;
                else map[i][j] = 9999;
            }
            dis[i] = 9999;
        }
        /**
         * 从times中获取信息
         */
        for(int i = 0;i<times.length;i++){
            map[times[i][0]-1][times[i][1]-1] = times[i][2];
        }
        dis[K-1] = 0;
        dijSln(K-1,N);
        int max = 0;
        for(int i = 0;i<N;i++){
            if(max<dis[i])max = dis[i];
        }
        if(max==9999)return -1;
        else
        return max;
    }
    public void dijSln(int k,int N){
      visited[k] = true;

        /**
         * i为还未被visit的某一个元素
         */
      for(int i = 0;i<N;i++){
          /**
           * 遍历一遍map 找出到为true点的最短距离
           *
           */
          if(visited[i]==false&&map[k][i]!=9999)dis[i] = Math.min(dis[i],dis[k]+map[k][i]);

      }
        /**
         * 判断是否全部顶点到达
         */
        boolean flag = true;
        for(int i = 0;i<N;i++){
            if(visited[i]==false)flag = false;
        }
        if(flag)return;
     int min = 9999;
      int index = N-1;

        /**
         *
         */
       boolean flag2 = false;
      for (int i = 0;i<N;i++){
          if(!visited[i]){
             if(min>dis[i]){
                 index = i; flag2 = true;
                 min = dis[i];
             }

          }
      }
      if(flag2==false)return;
      else
        dijSln(index,N);
    }

    public static void main(String[] args) {
        Solution743 sln = new Solution743();
        System.out.println(
                sln.networkDelayTime(new int[][]{{1,2,1},{2,3,2},{1,3,4}},3,1)
        );
    }

}