图论_最短路径_Dijistra算法_Leetcode743题

package first;
import java.util.Arrays;

 

public class Hello_world {
		public static void main(String[] args) {
			Hello_world Dijkstra = new Hello_world();
			int[][] times = {{2, 1, 1}, {2, 3, 1},{3, 4, 1}};
			System.out.println(Dijkstra.networkDelayTime(times, 4, 2));
			
		}
		public int networkDelayTime(int[][] times, int N, int K) {
        int graph[][] = new int[N+1][N+1];
        //构建邻接矩阵，存放距离
        for(int i = 1; i < N + 1; i++ ){
            for (int j = 1; j < N + 1; j++){
                graph[i][j] = -1;
            }
        }
        //用一维数组time[]遍历times[][]，times[i] []= （源节点，目标节点，时间）；
        for (int[] time : times){
            graph[time[0]][time[1]] = time[2];
        }

        //存放K到其他节点的最短路径
        int[] distance = new int[N + 1];
        Arrays.fill(distance, -1);

        //初始化距离（题目给的）
        for(int i = 1; i <= N; i++){
            distance[i] = graph[K][i]; 
        }

        distance[K] = 0;

        //储存各节点是否被访问
        boolean[] known = new boolean[N + 1];
        known[K] = true;

        //遍历除K本身的N-1个节点
        for(int i = 1; i < N; i++){
            int minDistance = Integer.MAX_VALUE;
            int minVertex = 1;
            //遍历所有节点，找到利K最近的节点
            for(int j = 1; j < N+1; j++){
                //该点未访问过，且存在该路径，该路径小于前一路径（不断更新最小路径）
                if(!known[j] && distance[j] != -1 && distance[j] < minDistance){
                    minDistance = distance[j];
                    minVertex = j;
                }
            }
            known[minVertex] = true;
         // 根据刚刚找到的最短距离节点，继续寻找到下一个节点，通过该节点更新K节点与其他的节点的距离
            for(int j = 1; j < N + 1; j++){
            	// 如果已更新的最短节点可以到达其他节点（还有路）
                if(graph[minVertex][j] != -1){
                	// 取之前路径与当前更新路径的最小值
                    if(distance[j] != -1){
                        distance[j] = Math.min(distance[j],distance[minVertex] + graph[minVertex][j]);
                    }else{
                    // 该节点是第一次访问，没有距离，直接更新，注意distance[j]，永远是K点和J点的关系，而不是前一个后一个
                    // k到j关系 = k到其权重最小的下一个节点 + 这个节点到最后节点的关系
                    //2->4 =  2->3 + 3->4，3是2最近的节点；
                        distance[j] = distance[minVertex] + graph[minVertex][j];
                    }
                }
            }
        }
        
        //最后存在最小路径则输出，到自身就直接0，不存在这样路径输出-1
        int minDistance = 0;
        for(int i= 1; i < N+1; i++){
            if(distance[i] == -1){
                return -1;
            }
            minDistance = Math.max(distance[i],minDistance);
        }
        return minDistance;
    }
}