用Dijkstra算法求单源最短路径

输入格式：
首先输入结点数量T ，起点start
后续T行每行三个数，分别是from 、next 、weigth,分别表示边的起点、终点、权

import java.util.*;

public class Dijkstra {
    static final int MAX=(int)(1e4+10);
    static int T;
    static int start
    //static int end;
    static ArrayList<LinkedList<Edge>> arrayList=new ArrayList<LinkedList<Edge>>(MAX);//领接表
    public static void main(String[] args) {
        init();
        dijkstra();
    }
    static void init(){//初始化
        Scanner cin=new Scanner(System.in);
        T=cin.nextInt();//结点数量/组数
        start=cin.nextInt();//起点
        //end=cin.nextInt();
        int from,to,weigth;
        for(int i=0;i<MAX;i++){
            LinkedList<Edge> temp=new LinkedList<>();
            arrayList.add(temp);
        }
        for(int i=0;i<T;i++){
            from=cin.nextInt();
            to=cin.nextInt();
            weigth=cin.nextInt();//权
            arrayList.get(from).add(new Edge(from,to,weigth));//领接表
            arrayList.get(to).add(new Edge(to,from,weigth));//领接表
        }
    }
    static void printAll(int[] path,int[] distance){
        int[] route=new int[MAX];
        for(int i=0;i<MAX;i++){
            if(path[i]==-1)
                continue;
            int k=-1;
            route[++k]=i;//start
            for(int j=i;path[j]!=j;j=path[j])
                route[++k]=path[j];
            if(k-1>=0){
                System.out.print(route[k]+"->"+route[0]+":"+route[k]);
                k--;
                while(k>=0){
                    System.out.print("->"+route[k--]);
                }
                System.out.println("  distance:"+distance[i]);
            }
        }
    }
    static void printEnd(int[] path,int[] distance){
        int[] route=new int[MAX];
        int k=-1;
        route[++k]=end;//start
        for(int j=end;path[j]!=j;j=path[j])
            route[++k]=path[j];
        if(k-1>=0){
            System.out.print(route[k]+"->"+route[0]+":"+route[k]);
            k--;
            while(k>=0){
                System.out.print("->"+route[k--]);
            }
            System.out.println("  distance:"+distance[end]);
        }
    }
    static void dijkstra(){
        int[] distance=new int[MAX];
        int[] path=new int[MAX];
        boolean[] isfind =new boolean[MAX];
        Arrays.fill(distance,Integer.MAX_VALUE);
        Arrays.fill(path,-1);
        distance[start]=0;
        path[start]=start;
        PriorityQueue<Node> priorityQueue=new PriorityQueue<Node>(new Comparator<Node>() {//优先队列
            @Override
            public int compare(Node o1, Node o2) {
                return o1.dis-o2.dis;//升序
            }
        });
        priorityQueue.add(new Node(start,distance[start]));
        while(!priorityQueue.isEmpty()){
            Node node=priorityQueue.poll();
            if(isfind[node.num])
                continue;
            isfind[node.num]=true;//该节点已经从优先队列出队,即已经是最短路径
            for(Edge edge:arrayList.get(node.num)){
                if(isfind[edge.next])
                    continue;
                if(distance[edge.next]> node.dis+edge.weigth){
                    distance[edge.next]=node.dis+edge.weigth;
                    priorityQueue.add(new Node(edge.next,distance[edge.next]));
                    path[edge.next]=node.num;
                }
            }
        }
        printAll(path,distance);
        //printEnd(path,distance);
        //System.out.println(distance[end]);
    }
}
class Node{//用于优先队列
    int num;
    int dis;
    Node(int num,int dis){
        this.num=num;
        this.dis=dis;
    }
}
class Edge{//用于领接表存结点信息
    public int from;
    public int next;
    public int weigth;
    Edge(int from,int next,int weigth){
        this.from=from;
        this.next=next;
        this.weigth=weigth;
    }
}