【數據結構與算法】 Floyd算法

核心思想：

 通過Floyd計算圖G=(V,E)中各個頂點的最短路徑時，需要引入一個矩陣S，矩陣S中的元素a[i][j]表示頂點i(第i個頂點)到頂點j(第j個頂點)的距離。假設圖G中頂點個數爲N，則需要對矩陣S進行N次更新。 初始時，矩陣S中頂點a[i][j]的距離爲頂點i到頂點j的權值；如果i和j不相鄰，則a[i][j]=∞。接下來開始，對矩陣S進行N次更新。第1次更新時，如果"a[i][j]的距離" > "a[i][0]+a[0][j]"(a[i][0]+a[0][j]表示"i與j之間經過第1個頂點的距離")，則更新a[i][j]爲"a[i][0]+a[0][j]"。同理，第k次更新時，如果"a[i][j]的距離" > "a[i][k]+a[k][j]"，則更新a[i][j]爲"a[i][k]+a[k][j]"。更新N次之後，操作完成！

過程圖解：

代碼：

package com.smart.reflect;


import java.io.IOException;
import java.util.Scanner;


public class MatrixUDG {

    private int mEdgNum;        // 邊的數量
    private char[] mVexs;       // 頂點集合
    private int[][] mMatrix;    // 鄰接矩陣
    private static final int INF = Integer.MAX_VALUE;   // 最大值

    /*
     * 創建圖(自己輸入數據)
     */
    public MatrixUDG() {

        // 輸入"頂點數"和"邊數"
        System.out.printf("input vertex number: ");
        int vlen = readInt();
        System.out.printf("input edge number: ");
        int elen = readInt();
        if (vlen < 1 || elen < 1 || (elen > (vlen * (vlen - 1)))) {
            System.out.printf("input error: invalid parameters!\n");
            return;
        }

        // 初始化"頂點"
        mVexs = new char[vlen];
        for (int i = 0; i < vlen; i++) {
            System.out.printf("vertex(%d): ", i);
            mVexs[i] = readChar();
        }

        // 1. 初始化"邊"的權值
        mEdgNum = elen;
        mMatrix = new int[vlen][vlen];
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                if (i == j)
                    mMatrix[i][j] = 0;
                else
                    mMatrix[i][j] = INF;
            }
        }

        // 2. 初始化"邊"的權值: 根據用戶的輸入進行初始化
        for (int i = 0; i < elen; i++) {
            // 讀取邊的起始頂點,結束頂點,權值
            System.out.printf("edge(%d):", i);
            char c1 = readChar();       // 讀取"起始頂點"
            char c2 = readChar();       // 讀取"結束頂點"
            int weight = readInt();     // 讀取"權值"

            int p1 = getPosition(c1);
            int p2 = getPosition(c2);
            if (p1 == -1 || p2 == -1) {
                System.out.printf("input error: invalid edge!\n");
                return;
            }

            //無向圖可以當成是兩條邊的有向圖
            mMatrix[p1][p2] = weight;
            mMatrix[p2][p1] = weight;
        }
    }

    /*
     * 創建圖(用已提供的矩陣)
     *
     * 參數說明：
     *     vexs  -- 頂點數組
     *     matrix-- 矩陣(數據)
     */
    public MatrixUDG(char[] vexs, int[][] matrix) {

        // 初始化"頂點數"和"邊數"
        int vlen = vexs.length;

        // 初始化"頂點"
        mVexs = new char[vlen];
        for (int i = 0; i < vlen; i++)
            mVexs[i] = vexs[i];

        // 初始化"邊"
        mMatrix = new int[vlen][vlen];
        for (int i = 0; i < vlen; i++)
            for (int j = 0; j < vlen; j++)
                mMatrix[i][j] = matrix[i][j];

        // 統計"邊"---這裏針對的是無向圖
        mEdgNum = 0;
        for (int i = 0; i < vlen; i++)
            for (int j = i + 1; j < vlen; j++)
                if (mMatrix[i][j] != INF)
                    mEdgNum++;
    }

    /*
     * 返回字符在數組中的位置
     */
    private int getPosition(char ch) {
        for (int i = 0; i < mVexs.length; i++)
            if (mVexs[i] == ch)
                return i;
        return -1;
    }

    /*
     * 讀取一個輸入字符
     */
    private char readChar() {
        char ch = '0';
        do {
            try {
                ch = (char) System.in.read(); //注意其用法 一定要加上while條件判斷 否則就會出錯
            } catch (IOException e) {
                e.printStackTrace();
            }
        } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
        return ch;
    }

    /*
     * 讀取一個輸入整數
     */
    private int readInt() {
        Scanner scanner = new Scanner(System.in);
        return scanner.nextInt();
    }

    /*
     * floyd最短路徑。
     * 即，統計圖中各個頂點間的最短路徑。
     *
     * 參數說明：
     *     path -- 路徑。path[i][j]=k表示，"頂點i"到"頂點j"的最短路徑會經過頂點k。
     *     dist -- 長度數組。即，dist[i][j]=sum表示，"頂點i"到"頂點j"的最短路徑的長度是sum。
     */
    public void floyd(int[][] path, int[][] dist) {
        int vlen = mVexs.length;//頂點數

        // 初始化
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                dist[i][j] = mMatrix[i][j];    // "頂點i"到"頂點j"的路徑長度爲"i到j的權值"。
                path[i][j] = j;                // "頂點i"到"頂點j"的最短路徑是經過頂點j。
            }
        }

        // 計算最短路徑
        for (int k = 0; k < vlen; k++) {
            for (int i = 0; i < vlen; i++) {
                for (int j = 0; j < vlen; j++) {
                    // 如果經過下標爲k頂點路徑比原兩點間路徑更短，則更新dist[i][j]和path[i][j]
                    int tmp = (dist[i][k] == INF || dist[k][j] == INF) ? INF : (dist[i][k] + dist[k][j]);
                    if (dist[i][j] > tmp) {  //如果有多條路徑值相等，則保留最初的一條
                        // "i到j最短路徑"對應的值設，爲更小的一個(即經過k)
                        dist[i][j] = tmp;
                        // "i到j最短路徑"對應的路徑，經過k
                        path[i][j] = path[i][k];
                    }
                }
            }
        }

        // 打印floyd最短路徑的結果
        System.out.printf("floyd: \n");
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++)
                System.out.printf("%2d  ", dist[i][j]);
            System.out.printf("\n");
        }
    }

    //打印floyd最短路徑的具體路徑  path[A][D]=F  沒有E輸出 因此需要遞歸
    //路徑只有兩種情況 要不就是ABI(B和I是相連通的) 要不就是AB......I(B和I之間還有需要元素)
    public void Pfloyd(int a, int b, int path[][]) {
        System.out.print(mVexs[a] + " ");
//        if (mMatrix[path[a][b]][b] == INF)  //原數組沒有變化
//        {
//            Pfloyd(path[a][b], b, path);
//        }else{
//            System.out.print(mVexs[path[a][b]]+" "+mVexs[b]);
//        }

        int x=path[a][b];
        while(x!=b){
            System.out.print(mVexs[x]+" ");
            x=path[x][b];
        }
        System.out.print(mVexs[x]);
    }


    public static void main(String[] args) {
        char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int matrix[][] = {
                 /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
          /*A*/ {0, 12, INF, INF, INF, 16, 14},
          /*B*/ {12, 0, 10, INF, INF, 7, INF},
          /*C*/ {INF, 10, 0, 3, 5, 6, INF},
          /*D*/ {INF, INF, 3, 0, 4, INF, INF},
          /*E*/ {INF, INF, 5, 4, 0, 2, 8},
          /*F*/ {16, 7, 6, 10000, 2, 0, 9},
          /*G*/ {14, INF, INF, INF, 8, 9, 0}};
        MatrixUDG pG;

        // 自定義"圖"(輸入矩陣隊列)
        //pG = new MatrixUDG();

        // 採用已有的"圖"
        pG = new MatrixUDG(vexs, matrix);

        int[][] path = new int[pG.mVexs.length][pG.mVexs.length];
        int[][] floy = new int[pG.mVexs.length][pG.mVexs.length];
        // floyd算法獲取各個頂點之間的最短距離
        pG.floyd(path, floy);

        //輸出任意兩點之間最短路徑長度以及其路徑    這裏不考慮輸入節點相同的情況 太簡單了
        System.out.println("請輸入任意兩節點：");
        int a = pG.getPosition(pG.readChar());
        int b = pG.getPosition(pG.readChar());
        System.out.println("兩節點之間最短路徑長度爲：" + floy[a][b]);
        System.out.print("兩節點之間路徑爲：");
        pG.Pfloyd(a, b, path);
    }
}