Dijkstra 最短路径

思路：
两个集合：
1.visted 存储已经访问过的结点
2.unVisted 存储未遍历过的结点
两个数组：
1.dist[] 存储1到每个结点的最短路径
2.path[] 存储到达该结点的最短路径的上一个结点

1.首先将1加入已经访问多过的结点的集合，然后将其他节点加入unVisted 集合。
2.经历n-1次循环，每次循环将unVisted 中的一个结点加入到visted 集合，并得到最短路径
3.节点k是到距离所有已访问节点最近的点
参考流程来自百度百科：

从1到其他节点的最短路径：
代码实现：

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

/**
 * Created by zfr on 2018/09/07.
 */
public class Dijkstra {
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();//节点的个数
        //下面输入两点之间的距离
        int M = scanner.nextInt();//M条边
        int[][] roads = new int[N+1][N+1] ;
        for(int i = 0 ;i<N+1;i++){
            for(int j = 0 ;j<N+1;j++){
                roads[i][j] = Integer.MAX_VALUE ;
            }
        }
        //有向图
        for(int i = 0 ;i<M ;i++){
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            roads[a][b] = scanner.nextInt();
        }
        //visted存放已经遍历的结点
        Set<Integer> visted = new HashSet<>();
        visted.add(1);//将起点1放进去
        //unVisted存放已经遍历的结点
        Set<Integer> unVisted = new HashSet<>();
        //将2~N放到未访问的结点中
        for(int i = 2;i<=N;i++){
            unVisted.add(i);
        }
        //dist[] 存放路径
        int[] dist = new int[N+1];
        int[] path = new int[N+1];//用于存放路径
        path[1] = 1;
        dist[1] = 0 ;//初始值
        //重复步骤n-1次 ，每次从未遍历的结点中找到与已经遍历的结点的最短距离
        for(int i = 0 ;i<N;i++){
            int min = Integer.MAX_VALUE ;//计算最短距离
            int min_start = 0;//产生最短距离的起点
            int min_end = 0 ;//产生最短距离的中点
            for (Integer start:
                 visted) {

                for (Integer end:
                    unVisted ) {
                    if( (roads[start][end] < min )&&(dist[start]+roads[start][end]) < min){
                        min = dist[start] + roads[start][end];
                        min_start = start ;
                        min_end = end ;
                    }
                }
            }
            visted.add(min_end);
            unVisted.remove(min_end);
            dist[min_end] = min;
            path[min_end] = min_start ;
        }
        //输出结果
        for (int i = 2; i <= N ; i++) {
            System.out.println("1到"+i+"的最短路径为 "+dist[i]+" ");
            StringBuilder stringBuilder = new StringBuilder();
            int index = i ;
            while (path[index] !=index){
                stringBuilder.append(index+"-");
                index = path[index];
            }
            stringBuilder.append(1);
            System.out.println("路径轨迹为："+stringBuilder.reverse().toString());
        }

    }
}

测试用例1：

5
10
1 2 10
1 5 5
2 5 2
5 2 3
2 3 1
5 3 9
5 4 2
4 3 6
3 4 4
4 1 7
1到2的最短路径为 8
路径轨迹为：1-5-2
1到3的最短路径为 9
路径轨迹为：1-5-2-3
1到4的最短路径为 7
路径轨迹为：1-5-4
1到5的最短路径为 5
路径轨迹为：1-5

测试用例2：

7 7
1 2 1
2 3 1
1 4 1
4 5 1
5 6 1
2 6 1
4 7 1
1到2的最短路径为 1
路径轨迹为：1-2
1到3的最短路径为 2
路径轨迹为：1-2-3
1到4的最短路径为 1
路径轨迹为：1-4
1到5的最短路径为 2
路径轨迹为：1-4-5
1到6的最短路径为 2
路径轨迹为：1-2-6
1到7的最短路径为 2
路径轨迹为：1-4-7