最短路徑—Dijkstra演算法和Floyd演算法

1、Dijkstra演算法

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

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

1.2、演算法描述
1)演算法思想：設G=(V,E)是一個帶權有向圖，把圖中頂點集合V分成兩組，第一組為已求出最短路徑的頂點集合

（用S表示，初始時S中只有一個源點，以後每求得一條最短路徑 , 就將加入到集合S中，直到全部頂點都加入到S中，演算法就結束了），第二組為其餘未確定最短路徑的頂點集合（用U表示），按最短路徑長度的遞增次序依次把第二組的頂點加入S中。在加入的過程中，總保持從源點v到S中各頂點的最短路徑長度不大於從源點v到U中任何頂點的最短路徑長度。此外，每個頂點對應一個距離，S中的頂點的距離就是從v到此頂點的最短路徑長度，U中的頂點的距離，是從v到此頂點只包括S中的頂點為中間頂點的當前最短路徑長度。

2)演算法步驟：
a.初始時，S只包含源點，即S＝{v}，v的距離為0。U包含除v外的其他頂點，即:U={其餘頂點}，若v與U中頂點u有邊，則<u,v>正常有權值，若u不是v的出邊鄰接點，則<u,v>權值為∞。
b.從U中選取一個距離v最小的頂點k，把k，加入S中（該選定的距離就是v到k的最短路徑長度）。
c.以k為新考慮的中間點，修改U中各頂點的距離；若從源點v到頂點u的距離（經過頂點k）比原來距離（不經過頂點k）短，則修改頂點u的距離值，修改後的距離值的頂點k的距離加上邊上的權。
d.重複步驟b和c直到所有頂點都包含在S中。

執行動畫過程如下圖

                                               

程式碼實現如下：

public class GraphByMatrix {
    public static final boolean UNDIRECTED_GRAPH = false;//無向圖標誌
    public static final boolean DIRECTED_GRAPH = true;//有向圖標誌

    public static final boolean ADJACENCY_MATRIX = true;//鄰接矩陣實現
    public static final boolean ADJACENCY_LIST = false;//鄰接表實現

    public static final int MAX_VALUE = Integer.MAX_VALUE;
    private boolean graphType;
    private boolean method;
    private int vertexSize;
    private int matrixMaxVertex;

    //儲存所有頂點資訊的一維陣列
    private Object[] vertexesArray;
    //儲存圖中頂點之間關聯關係的二維陣列,及邊的關係
    private int[][] edgesMatrix;

    // 記錄第i個節點是否被訪問過
    private boolean[] visited;

    /**
     * @param graphType 圖的型別：有向圖/無向圖
     * @param method    圖的實現方式：鄰接矩陣/鄰接表
     */
    public GraphByMatrix(boolean graphType, boolean method, int size) {
        this.graphType = graphType;
        this.method = method;
        this.vertexSize = 0;
        this.matrixMaxVertex = size;

        if (this.method) {
            visited = new boolean[matrixMaxVertex];
            vertexesArray = new Object[matrixMaxVertex];
            edgesMatrix = new int[matrixMaxVertex][matrixMaxVertex];

            //對陣列進行初始化，頂點間沒有邊關聯的值為Integer型別的最大值
            for (int row = 0; row < edgesMatrix.length; row++) {
                for (int column = 0; column < edgesMatrix.length; column++) {
                    edgesMatrix[row][column] = MAX_VALUE;
                }
            }

        }
    }

    /********************最短路徑****************************/
    //計算一個頂點到其它一個頂點的最短距離
    public void Dijkstra(Object obj) throws Exception {
        Dijkstra(getVertexIndex(obj));
    }
    public void Dijkstra(int v0) {
        int[] dist = new int[matrixMaxVertex];
        int[] prev = new int[matrixMaxVertex];

        //初始化visited、dist和path
        for (int i = 0; i < vertexSize; i++) {
            //一開始假定取直達路徑最短
            dist[i] = edgesMatrix[v0][i];
            visited[i] = false;

            //直達情況下的最後經由點就是出發點
            if (i != v0 && dist[i] < MAX_VALUE)
                prev[i] = v0;
            else
                prev[i] = -1; //無直達路徑
        }

        //初始時源點v0∈visited集，表示v0 到v0的最短路徑已經找到
        visited[v0] = true;

        // 下來假設經由一個點中轉到達其餘各點,會近些,驗證之
        // 再假設經由兩個點中轉,會更近些,驗證之,.....
        // 直到窮舉完所有可能的中轉點
        int minDist;
        int v = 0;
        for (int i = 1; i < vertexSize; i++) {
            //挑一個距離最近經由點,下標裝入 v
            minDist = MAX_VALUE;

            for (int j = 0; j < vertexSize; j++) {
                if ((!visited[j]) && dist[j] < minDist) {
                    v = j;                             // 經由頂點j中轉則距離更短
                    minDist = dist[j];
                }
            }
            visited[v] = true;

            /*頂點v併入S，由v0到達v頂點的最短路徑為min.
              假定由v0到v，再由v直達其餘各點，更新當前最後一個經由點及距離*/
            for (int j = 0; j < vertexSize; j++) {
                if ((!visited[j]) && edgesMatrix[v][j] < MAX_VALUE) {

                    if (minDist + edgesMatrix[v][j] <= dist[j]) {
                        //如果多經由一個v點到達j點的 最短路徑反而要短,就更新
                        dist[j] = minDist + edgesMatrix[v][j];

                        prev[j] = v;                    //經由點的序號
                    }

                }
            }

        }

        for (int i = 1; i < matrixMaxVertex; i++) {
            System.out.println("**" + vertexesArray[v0] + "-->" +vertexesArray[i] + " 的最短路徑是：" + dist[i]);
        }
    }

    //獲取頂點值在數組裡對應的索引
    private int getVertexIndex(Object obj) throws Exception {
        int index = -1;
        for (int i = 0; i < vertexSize; i++) {
            if (vertexesArray[i].equals(obj)) {
                index = i;
                break;
            }
        }
        if (index == -1) {
            throw new Exception("沒有這個值！");
        }

        return index;
    }

    /**
     * 單源最短路徑演算法，用於計算一個節點到其他!!所有節點!!的最短路徑
     */
    public void Dijkstra2(int v0) {
        // LinkedList實現了Queue介面 FIFO
        Queue<Integer> queue = new LinkedList<Integer>();
        for (int i = 0; i < vertexSize; i++) {
            visited[i] = false;
        }

        //這個迴圈是為了確保每個頂點都被遍歷到
        for (int i = 0; i < vertexSize; i++) {
            if (!visited[i]) {
                queue.add(i);
                visited[i] = true;

                while (!queue.isEmpty()) {
                    int row = queue.remove();
                    System.out.print(vertexesArray[row] + "-->");

                    for (int k = getMin(row); k >= 0; k = getMin(row)) {
                        if (!visited[k]) {
                            queue.add(k);
                            visited[k] = true;
                        }
                    }

                }
            }
        }
    }

    private int getMin( int row) {
        int minDist = MAX_VALUE;
        int index = 0;
        for (int j = 0; j < vertexSize; j++) {
            if ((!visited[j]) && edgesMatrix[row][j] < minDist) {
                minDist = edgesMatrix[row][j];
                index = j;
            }
        }
        if (index == 0) {
            return -1;
        }
        return index;
    }

    public boolean addVertex(Object val) {
        assert (val != null);
        vertexesArray[vertexSize] = val;
        vertexSize++;
        return true;
    }

    public boolean addEdge(int vnum1, int vnum2, int weight) {
        assert (vnum1 >= 0 && vnum2 >= 0 && vnum1 != vnum2 && weight >= 0);

        //有向圖
        if (graphType) {
            edgesMatrix[vnum1][vnum2] = weight;

        } else {
            edgesMatrix[vnum1][vnum2] = weight;
            edgesMatrix[vnum2][vnum1] = weight;
        }

        return true;
    }

}
 

測試：

    @Test
    public void testWeight() throws Exception {
        GraphByMatrix graph = new GraphByMatrix(Graph.UNDIRECTED_GRAPH, Graph.ADJACENCY_MATRIX, 6);

        graph.addVertex("1");
        graph.addVertex("2");
        graph.addVertex("3");
        graph.addVertex("4");
        graph.addVertex("5");
        graph.addVertex("6");

        graph.addEdge(0, 1,7);
        graph.addEdge(0, 2,9);
        graph.addEdge(0, 5,14);

        graph.addEdge(1, 3,15);
        graph.addEdge(1, 2,10);

        graph.addEdge(2, 3,11);
        graph.addEdge(2, 5,2);

        graph.addEdge(3, 4,6);
        graph.addEdge(4, 5,9);

        graph.Dijkstra(0);
        System.out.println();
        graph.Dijkstra("1");
        System.out.println();
        graph.Dijkstra2(0);
        System.out.println();
    }

**1-->2 的最短路徑是：7
**1-->3 的最短路徑是：9
**1-->4 的最短路徑是：20
**1-->5 的最短路徑是：20
**1-->6 的最短路徑是：11

**1-->2 的最短路徑是：7
**1-->3 的最短路徑是：9
**1-->4 的最短路徑是：20
**1-->5 的最短路徑是：20

**1-->6 的最短路徑是：11

1-->2-->3-->6-->4-->5-->

2、Floyd演算法：讀弗洛伊德

1.定義概覽
Floyd-Warshall演算法（Floyd-Warshall algorithm）又稱為插點法是解決任意兩點間的最短路徑的一種演算法，可以正確處理有向圖或負權的最短路徑問題，同時也被用於計算有向圖的傳遞閉包。Floyd-Warshall演算法的時間複雜度為O(N3)，空間複雜度為O(N2)。

2.演算法描述：

1)演算法思想原理：
     Floyd演算法是一個經典的動態規劃演算法。用通俗的語言來描述的話，首先我們的目標是尋找從點i到點j的最短路徑。從動態規劃的角度看問題，我們需要為這個目標重新做一個詮釋（這個詮釋正是動態規劃最富創造力的精華所在）

    從任意節點i到任意節點j的最短路徑不外乎2種可能，1是直接從i到j，2是從i經過若干個節點k到j。所以，我們假設Dis(i,j)為節點u到節點v的最短路徑的距離，對於每一個節點k，我們檢查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，證明從i到k再到j的路徑比i直接到j的路徑短，我們便設置Dis(i,j) = Dis(i,k) + Dis(k,j)，這樣一來，當我們遍歷完所有節點k，Dis(i,j)中記錄的便是i到j的最短路徑的距離。

2).演算法描述：
a.從任意一條單邊路徑開始。所有兩點之間的距離是邊的權，如果兩點之間沒有邊相連，則權為無窮大。 　　
b.對於每一對頂點 u 和 v，看看是否存在一個頂點 w 使得從 u 到 w 再到 v 比己知的路徑更短。如果是更新它。

3).Floyd演算法過程矩陣的計算----十字交叉法
方法：兩條線，從左上角開始計算一直到右下角 如下所示

給出矩陣，其中矩陣A是鄰接矩陣，而矩陣Path記錄u,v兩點之間最短路徑所必須經過的點

     

相應計算方法如下：

最後A₃即為所求結果

程式碼如下：

   public void shortestPath_FLOYD() {
        int n = vertexSize;
        int[][] D = new int[n][n];//儲存從i到j的最小路徑值
        int[][] p = new int[n][n];//儲存經過的中間節點
        for (int i = 0; i < n; i++) {//初始化D，p
            for (int j = 0; j < n; j++) {
                if (edgesMatrix[i][j] < Integer.MAX_VALUE) {

                    p[i][j] = j;
                } else {
                    p[i][j] = -1;
                }
                D[i][j] = edgesMatrix[i][j];
            }
        }

        for (int x = 0; x < n; x++) {//進行Floyd演算法，從0到n-1所有可能進行遍歷
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (D[i][j] > D[i][x] + D[x][j]) {
                        D[i][j] = D[i][x] + D[x][j];
                        p[i][j] = p[i][x];
                    }
                }
            }
        }
        // 下面對獲得的結果進行展示
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(" " + D[i][j]);
            }
            System.out.println();
        }
        System.out.println("++++++++++++++++++++++++++++++++++++");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(" " + p[i][j]);
            }
            System.out.println();
        }
        System.out.println("+++++++++++++++++++++++++++++++++++");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.println("輸出i=" + i + "到j=" + j + "最短路徑：");
                int k = p[i][j];
                if (k == -1) {
                    System.out.println("沒有最短路徑");
                } else {
                    System.out.print(" " + k);
                    while (k != j) {
                        k = p[k][j];
                        System.out.print(" " + k);
                    }
//                  System.out.println(" "+k);
                    System.out.println();
                }
            }
        }
    }