京東一面：圖中兩個頂點的最短路徑——Dijkstra算法原理

數據結構好像忘了看關於圖的，然後只說了，深度優先遍歷和廣度優先遍歷。

原文地址:

http://www.cnblogs.com/skywang12345/p/3711516.html

Dijkstra算法

1.定義概覽

Dijkstra(迪傑斯特拉)算法是典型的單源最短路徑算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點爲中心向外層層擴展，直到擴展到終點爲止。Dijkstra算法是很有代表性的最短路徑算法，在很多專業課程中都作爲基本內容有詳細的介紹，如數據結構，圖論，運籌學等等。注意該算法要求圖中不存在負權邊。

問題描述：在無向圖 G=(V,E) 中，假設每條邊 E[i] 的長度爲 w[i]，找到由頂點 V0 到其餘各點的最短路徑。（單源最短路徑）

 

2.算法描述(算法很抽象，直接看例子)

1)算法思想：設G=(V,E)是一個帶權有向圖，把圖中頂點集合V分成兩組，第一組爲已求出最短路徑的頂點集合（用S表示，初始時S中只有一個源點，以後每求得一條最短路徑 , 就將加入到集合S中，直到全部頂點都加入到S中，算法就結束了），第二組爲其餘未確定最短路徑的頂點集合（用U表示），按最短路徑長度的遞增次序依次把第二組的頂點加入S中。在加入的過程中，總保持從源點v到S中各頂點的最短路徑長度不大於從源點v到U中任何頂點的最短路徑長度。此外，每個頂點對應一個距離，S中的頂點的距離就是從v到此頂點的最短路徑長度，U中的頂點的距離，是從v到此頂點只包括S中的頂點爲中間頂點的當前最短路徑長度。

(1) 初始時，S只包含起點s；U包含除s外的其他頂點，且U中頂點的距離爲”起點s到該頂點的距離”[例如，U中頂點v的距離爲(s,v)的長度，然後s和v不相鄰，則v的距離爲∞]。

(2) 從U中選出”距離最短的頂點k”，並將頂點k加入到S中；同時，從U中移除頂點k。

(3) 更新U中各個頂點到起點s的距離。之所以更新U中頂點的距離，是由於上一步中確定了k是求出最短路徑的頂點，從而可以利用k來更新其它頂點的距離；例如，(s,v)的距離可能大於(s,k)+(k,v)的距離。

(4) 重複步驟(2)和(3)，直到遍歷完所有頂點。

 

以上圖G4爲例，來對迪傑斯特拉進行算法演示(以第4個頂點D爲起點)。

初始狀態：S是已計算出最短路徑的頂點集合，U是未計算除最短路徑的頂點的集合！
第1步：將頂點D加入到S中。
    此時，S={D(0)}, U={A(∞),B(∞),C(3),E(4),F(∞),G(∞)}。     注:C(3)表示C到起點D的距離是3。

第2步：將頂點C加入到S中。
    上一步操作之後，U中頂點C到起點D的距離最短；因此，將C加入到S中，同時更新U中頂點的距離。以頂點F爲例，之前F到D的距離爲∞；但是將C加入到S之後，F到D的距離爲9=(F,C)+(C,D)。
    此時，S={D(0),C(3)}, U={A(∞),B(23),E(4),F(9),G(∞)}。

第3步：將頂點E加入到S中。
    上一步操作之後，U中頂點E到起點D的距離最短；因此，將E加入到S中，同時更新U中頂點的距離。還是以頂點F爲例，之前F到D的距離爲9；但是將E加入到S之後，F到D的距離爲6=(F,E)+(E,D)。
    此時，S={D(0),C(3),E(4)}, U={A(∞),B(23),F(6),G(12)}。

第4步：將頂點F加入到S中。
    此時，S={D(0),C(3),E(4),F(6)}, U={A(22),B(13),G(12)}。

第5步：將頂點G加入到S中。
    此時，S={D(0),C(3),E(4),F(6),G(12)}, U={A(22),B(13)}。

第6步：將頂點B加入到S中。
    此時，S={D(0),C(3),E(4),F(6),G(12),B(13)}, U={A(22)}。

第7步：將頂點A加入到S中。
    此時，S={D(0),C(3),E(4),F(6),G(12),B(13),A(22)}。

此時，起點D到各個頂點的最短距離就計算出來了：A(22) B(13) C(3) D(0) E(4) F(6) G(12)。

例子中的B{13}寫錯了

java代碼：

public class dijkstraMethod {
    private final int INF = Integer.MAX_VALUE;
    int [][] Matrix;
    char[] Nodes;
    public dijkstraMethod(char[] Nodes, int [][] Matrix)
    {
        this.Nodes = Nodes;
        this.Matrix = Matrix;
    }

    /**
     *
     * @param node
     * @param distance
     */
    public void dijkstra(int node, int [] distance)
    {
        boolean [] flag = new boolean[Nodes.length];
        for(int i = 0 ;i<Nodes.length;i++)
        {
            flag[i] = false;
            distance[i] = Matrix[node][i];
        }
        flag[node] = true;
        distance[node] = 0;
        int k = 0;
        for(int i = 1;i<Nodes.length;i++)
        {
            int min = INF;
            for(int j = 0;j<Nodes.length;j++)
            {
                if(!flag[j]&&distance[j] < min)
                {
                    k = j;
                    min = distance[j];
                }
            }
            flag[k] = true;

            for(int j = 0;j<Nodes.length;j++)
            {
                int len = Matrix[k][j] ==INF?INF:min+Matrix[k][j];
                if(!flag[j]&&len<distance[j])
                    distance[j] = len;
            }
        }
        System.out.printf("Dijkstra(%c): \n", Nodes[node]);
        for(int i = 0; i<Nodes.length;i++)
        {
            System.out.printf(" shortest(%c, %c) = %d\n", Nodes[node],Nodes[i], distance[i]);
        }
    }

    public static void main(String[] args) {
        int INF = Integer.MAX_VALUE;

        char[] Nodes = {'A', 'B', 'C', 'D', 'E'};
        int matrix[][] = {
                /*A*//*B*//*C*//*D*/
                /*A*/ {0,1,5,INF,INF},
                /*B*/ {1,0,2,4,INF},
                /*C*/ {5,2,0,1,1},
                /*D*/ {INF,4,1,0,2},
                      {INF,INF,1,2,0}
        };

        int[] dist = new int[Nodes.length];

        dijkstraMethod dijkstra = new dijkstraMethod(Nodes, matrix);
        dijkstra.dijkstra(2, dist);

    }

}