弗洛伊德(Floyd)算法求所有顶点到其他顶点的最短路径

---

一、弗洛伊德算法是什么？

Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似,不同点在于,Dijkstra算法一次性只能计算出某一个端点到其他端点的最短路径,而Floyd算法可以计算出所有端点到其他端点的最短路径,虽然它们的时间复杂度都是n的3次方,但是Floyd算法很简洁优雅。

二、原理

任意两端点i、j，如果存在中间端点k，满足 i->k 和 k -> j 的权值之和小于 i -> j 则用 i ->k ->j 来替换 i -> j 的路径，否则不变，其中 i -> k 可以是逻辑上的边也可以是实际上的边。
怎么理解逻辑上的边呢?
就是说 i 和 k没有直接边 ，因此 i -> k 的权值理论上是无穷大。 i->k 中间有个端点a，即a和i、k都有边，满足 i -> a 和 a -> k的权值之和是有限值肯定小于无穷大，因此i -> k 就可以用 i -> a -> k来替换了，因此 i ->j 实际路径就说 i -> a -> k ->j。看到这里我想大家应该都明白了，弗洛伊德算法就是利用中间端点不断找到两个端点间的最短路径。

三、实现步骤

1. 初始化图
2. 初始化权值表和最短路径表,其中最短路径表中默认直连;权值表不存在表的默认为无穷大
3. 以每个端点做为中间端点,循环遍历去更新两个端点的最短路径及权值
4. 遍历打印所有端点到其他端点的最短路径

四、实现代码

代码如下（示例）：

public class Test {

    /**
     * 端点矩阵  图
     */
    private static final int[][] GRAPH;

    /**
     * 路径表
     * SHORT_PATH_TABLE[i][j] == j 表示 i -> j直达，没有经过中间节点进行转换
     */
    private static final int[][] SHORT_PATH_TABLE;

    /**
     * 权值表
     */
    private static final int[][] WEIGHT_TABLE;

    /**
     * 判断两节点是否存在边
     */
    private static final int NOT_DIRECT_FLAG = -1;


    static {
        GRAPH = new int[9][9];
        SHORT_PATH_TABLE = new int[9][9];
        WEIGHT_TABLE = new int[9][9];
        initGraph();
        initShortPathAndWeight();

    }

    /**
     * 初始化路径和权值
     */
    public static void initShortPathAndWeight() {

        for (int i = 0; i < GRAPH.length; i++) {
            for (int j = 0; j < GRAPH.length; j++) {
                WEIGHT_TABLE[i][j] = GRAPH[i][j];
                // 默认所有 i -> j 路径都是直达
                SHORT_PATH_TABLE[i][j] = j;
            }
        }
    }

    /**
     * 初始化图表
     */
    public static void initGraph() {
        for (int i = 0; i < GRAPH.length; i++) {
            for (int j = 0; j < GRAPH[i].length; j++) {
                if (i == j) {
                    GRAPH[i][j] = 0;
                } else {
                    GRAPH[i][j] = Integer.MAX_VALUE;
                }

            }
        }
        GRAPH[0][1] = 1;
        GRAPH[1][0] = 1;

        GRAPH[0][2] = 5;
        GRAPH[2][0] = 5;

        GRAPH[1][2] = 3;
        GRAPH[2][1] = 3;

        GRAPH[1][3] = 7;
        GRAPH[3][1] = 7;

        GRAPH[1][4] = 5;
        GRAPH[4][1] = 5;

        GRAPH[2][4] = 1;
        GRAPH[4][2] = 1;

        GRAPH[2][5] = 7;
        GRAPH[5][2] = 7;

        GRAPH[4][3] = 2;
        GRAPH[3][4] = 2;

        GRAPH[6][3] = 3;
        GRAPH[3][6] = 3;

        GRAPH[4][6] = 6;
        GRAPH[6][4] = 6;

        GRAPH[4][7] = 9;
        GRAPH[7][4] = 9;

        GRAPH[4][5] = 3;
        GRAPH[5][4] = 3;

        GRAPH[5][7] = 5;
        GRAPH[7][5] = 5;

        GRAPH[6][7] = 2;
        GRAPH[7][6] = 2;

        GRAPH[6][8] = 7;
        GRAPH[8][6] = 7;

        GRAPH[7][8] = 4;
        GRAPH[8][7] = 4;
    }

    public static void main(String[] args) {
        calculateShortPathAndWeight();
        getShortPathAndWeight();
    }

    /**
     * 计算最短路径和权值
     * 核心代码
     * 时间复杂度n的3次方
     */
    private static void calculateShortPathAndWeight() {

        for (int k = 0; k < GRAPH.length; k++) {
            for (int i = 0; i < GRAPH.length; i++) {
                for (int j = 0; j < GRAPH.length; j++) {
                    if (WEIGHT_TABLE[i][j] > (long) WEIGHT_TABLE[i][k] + (long) WEIGHT_TABLE[k][j]) {
                        WEIGHT_TABLE[i][j] = WEIGHT_TABLE[i][k] + WEIGHT_TABLE[k][j];
                        SHORT_PATH_TABLE[i][j] = SHORT_PATH_TABLE[i][k];
                    }
                }
            }
        }

    }

    /**
     * 遍历所有顶点到其他顶点的最短路径
     */
    private static void getShortPathAndWeight() {
        System.out.print("各顶点到其他顶点最小权值和最短路径如下：");
        for (int i = 0; i < GRAPH.length; i++) {
            for (int j = 0; j < GRAPH.length; j++) {
                System.out.print(String.format("v%s-v%s weight: %s ;", i, j, WEIGHT_TABLE[i][j]));
                int index = SHORT_PATH_TABLE[i][j];
                System.out.print(String.format("path: %s", i));
                while (index != j) {
                    System.out.print(String.format(" -> %s", index));
                    index = SHORT_PATH_TABLE[index][j];
                }
                System.out.print(String.format(" -> %s \n", j));
            }
        }
    }

}

总结

先看原理再看代码，理解原理就很好弄懂弗洛伊德(Floyd)算法了.