ACM_dijkstra单源最短路

时间复杂度

O(E + VlogV) E是边数, V是顶点数

具体算法

dijkstra算法:找单源最短路的算法， 单源指的是起点固定且只有1个， 求到其他点的最短距离， 终点也固定的叫两点间的最短距离， 两种情况的复杂度是一样的， 所以都转化成单源最短路解决；
如图：求1到其他点的最短路!

PS ： dijkstra仅适用于边权为正的情况；
dijksta是不断选出距离最小的点并不断的利用这个点更新相邻的点；

图形演示

比如上图：

证明：该性质描述为：如果P(i,j)={Vi….Vk..Vs…Vj}是从顶点i到j的最短路径，k和s是这条路径上的一个中间顶点，那么P(k,s)必定是从k到s的最短路径。下面证明该性质的正确性。

　　假设P(i,j)={Vi….Vk..Vs…Vj}是从顶点i到j的最短路径，则有P(i,j)=P(i,k)+P(k,s)+P(s,j)。而P(k,s)不是从k到s的最短距离，那么必定存在另一条从k到s的最短路径P’(k,s)，那么P’(i,j)=P(i,k)+P’(k,s)+P(s,j) < P(i,j)。则与P(i,j)是从i到j的最短路径相矛盾。因此该性质得证。

代码

import java.util.Scanner;
import java.util.Vector;

/**
 * Created by fkjslee on 2017/4/1.
 */
public class Main {
    static public void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            Integer n = in.nextInt();
            Integer m = in.nextInt();
            Vector[] graph = new Vector[205];
            for(Integer i = 0; i < 205; ++i)
                graph[i] = new Vector();
            for(Integer i = 0; i < m; ++i) {
                Integer a = in.nextInt();
                Integer b = in.nextInt();
                Integer x = in.nextInt();
                graph[a].add(new Node(b, x));
                graph[b].add(new Node(a, x));
            }
            Integer s = in.nextInt();
            Integer[] dis = dijkstra(graph, s);
            for(Integer i = 1; i <= n; ++i)
                System.out.println("到" + i + "点的最短距离\t" + dis[i]);
        }
        in.close();
    }

    /**
     * 使用的时候需要包含DijEle和Node两个类
     * @param graph 传入的需要计算最短路的图
     * @param startPoint 起始点
     * @return 到每个点的最短距离
     * 复杂度 O(VlogV + E)
     * */
    private static Integer[] dijkstra(Vector[] graph, Integer startPoint) {
        Integer[] dis = new Integer[graph.length];
        for(Integer i = 0; i < graph.length; ++i)
            dis[i] = 0x3f3f3f3f;
        dis[startPoint] = 0;
        PriorityQueue pq = new PriorityQueue();
        pq.add(new DijEle(startPoint, 0));

        while(!pq.isEmpty()) {
            DijEle nowPoint = (DijEle)pq.poll();
            for(Integer i = 0; i < graph[nowPoint.dijNode].size(); ++i) {
                Node son = (Node)(graph[nowPoint.dijNode].elementAt(i));
                Integer newDis = nowPoint.dijDis + son.edgeValue;
                if(newDis < dis[son.sonNode]) {
                    dis[son.sonNode] = newDis;
                    pq.add(new DijEle(son.sonNode, newDis));
                }
            }
        }
        return dis;
    }

    //dijkstra用于记录点的数据, 包括点名和距离
    private static class DijEle implements Comparable{
        private Integer dijDis;
        private Integer dijNode;

        private DijEle(Integer dijNode, Integer dijDis) {
            this.dijDis = dijDis;
            this.dijNode = dijNode;
        }

        @Override
        public int compareTo(Object o) {
            return (dijDis.compareTo(((DijEle)o).dijDis));
        }
    }
    //一些点的信息
    private static class Node {
        private Integer sonNode;
        private Integer edgeValue;

        private Node(Integer sonNode, Integer edgeValue) {
            this.sonNode = sonNode;
            this.edgeValue = edgeValue;
        }
    }
}

上图的输入:
6 9
1 2 8
1 5 11
1 6 17
2 3 13
2 4 9
3 4 5
3 5 12
4 5 7
5 6 5
1