dijkstra求单源最短路径（java）

dijkstra算法：求单源最短路径，算法内部设有

//记录路径;
int[] path=new int[n];
//记录点是否被访问过;
boolean[] visited=new boolean[n];
//记录开销;
int[] cost=new int[n];

等数组记录，针对下图：

具体代码如下：

import java.util.Stack;

public class ShortestPathDijkstra {
    public static void main(String[] args) {
        int MAX = Integer.MAX_VALUE;    // 无法到达时距离设为 Integer.MAX_VALUE
        int[][] matrix={
                {0,1,12,MAX,MAX,MAX},
                {MAX,0,9,3,MAX,MAX},
                {MAX,MAX,0,MAX,5,MAX},
                {MAX,MAX,4,0,13,15},
                {MAX,MAX,MAX,MAX,0,4},
                {MAX,MAX,MAX,MAX,MAX,0}
        };
        int start = 0,n=matrix.length;
        dijkstra(start,n,matrix);
    }

    private static void dijkstra(int start, int n,int[][] matrix) {
        int MAX = Integer.MAX_VALUE;    // 无法到达时距离设为 Integer.MAX_VALUE
        //记录路径;
        int[] path=new int[n];
        //记录点是否被访问过;
        boolean[] visited=new boolean[n];
        //记录开销;
        int[] cost=new int[n];
        //初始化Path
        for (int i = 0; i < n; i++) {
            path[i]=i;
        }
        //初始化cost
        for (int i = 0; i < n; i++) {
            cost[i]=matrix[start][i];
        }
        visited[start]=true;
        //每趟加入一个顶点，总共n-1趟
        for (int i = 0; i < n - 1; i++) {
            //选一个距离最近的点v；
            int v=-1;
            int minCost=MAX;
            for (int j = 0; j < n; j++) {
                if(!visited[j]&&minCost>cost[j]){
                    minCost=cost[j];
                    v=j;
                }
            }
            //将点v加入点集；
            visited[v]=true;
            //更新其余点到start的距离；
            for (int j = 0; j < n; j++) {
                if(!visited[j]&&matrix[v][j]<MAX&&matrix[v][j]+matrix[start][v]<matrix[start][j]){
                    //cost[j]=matrix[v][j]+matrix[start][v];错误，正确如下；
                    cost[j]=matrix[v][j]+cost[v];
                    path[j]=v;
                }
            }
        }
        //打印路径
        for (int i = 0; i < n; i++) {
            System.out.print("("+start+","+i+")的最短路径为："+cost[i]+","+start);
            Stack<Integer> sta=new Stack<>();
            int k=i;
            while(path[k]!=k){
                sta.push(path[k]);
                k=path[k];
            }
            while(!sta.isEmpty()){
                System.out.print("->"+sta.pop());
            }
            System.out.println("->"+i);
        }
    }
}

输出如下：

(0,0)的最短路径为：0,0->0
(0,1)的最短路径为：1,0->1
(0,2)的最短路径为：8,0->1->3->2
(0,3)的最短路径为：4,0->1->3
(0,4)的最短路径为：13,0->1->3->2->4
(0,5)的最短路径为：17,0->1->3->2->4->5