算法-最短路径算法(弗洛伊德算法 Floyd`s algorithm)

概述

• 弗洛伊德算法(Floyd’s algorithm)也是最短路径算法, 用于计算图中各个顶点之间的最短路径. 与迪杰斯特拉算法(Dijkstra’s algorithm)不同的是, 迪杰斯特拉算法是指定某一个顶点到其它顶点的最短路径, 而弗洛伊德算法是每一个(所有)顶点到其它顶点的最短路径

最短路径问题

1. 胜利乡有7个村庄(A,B,C,D,E,F,G)
2. 各个村庄的距离用边线权值来表示, 比如 A-B距离5公里

• 计算出各个村庄到其它各个村庄的最短距离
  

• 代码实现

public class FloydAlgorithmApp {
    /** 定义顶点*/
    private static final char[] vertexes = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    /** 定义常量, 9999表示某顶点间不连通*/
    private static final int N = 9999;
    public static void main(String[] args) {
        /** 邻接矩阵*/
        int[][] matrix = new int[vertexes.length][vertexes.length];
        matrix[0] = new int[]{0, 5, 7, N, N, N, 2};
        matrix[1] = new int[]{5, 0, N, 9, N, N, 3};
        matrix[2] = new int[]{7, N, 0, N, 8, N, N};
        matrix[3] = new int[]{N, 9, N, 0, N, 4, N};
        matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};
        matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};
        matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};
        FloydGraph graph = new FloydGraph(vertexes, matrix);
        /** 求出最短路径*/
        graph.floyd();
        /** 打印结果*/
        graph.show();
    }
}

class FloydGraph {
    /** 顶点数组*/
    private char[] vertexes;
    /** 邻接矩阵: 保存各个顶点之间距离, 最后求出的结果, 也保留在该数组*/
    private int[][] matrix;
    /** 保存到达目标顶点的前驱顶点*/
    private int[][] preVertexes;

    /**
     * @param vertexes 顶点数组
     * @param matrix 邻接矩阵
     */
    public FloydGraph(char[] vertexes, int[][] matrix) {
        this.vertexes = vertexes;
        this.matrix = matrix;
        this.preVertexes = new int[vertexes.length][vertexes.length];
        /** 初始化前驱顶点数组, 存放前驱顶点的下标*/
        for (int i = 0; i < vertexes.length; i++) {
            Arrays.fill(preVertexes[i], i);
        }
    }

    /** 求出最短路径(通过弗洛伊德算法实现的)*/
    public void floyd() {
        int distance = 0;
        /** 对中间顶点遍历, k就是中间顶点的下标 [A, B, C, D, E, F, G]*/
        for (int k = 0; k < matrix.length; k++) {
            /** 从 i顶点开始出发 [A, B, C, D, E, F, G]*/
            for (int i = 0; i < matrix.length; i++) {
                /** 到达 j顶点 [A, B, C, D, E, F, G]*/
                for (int j = 0; j < matrix.length; j++) {
                    /** (从 i顶点出发到 k中间顶点的距离) + (k中间顶点到 j顶点的距离)
                     * 当 k作为中间顶点 A时
                     * 1. C-A-G(9)
                     * 2. C-A-B(12)
                     * 3. G-A-B(7)*/
                    distance = matrix[i][k] + matrix[k][j];
                    /** 如果 distance小于直连的距离(matrix[i][j])
                     * 当 G-A-B(7)时, 由于 G到B本来是3结果绕过A, 会导致变的更长就不会被更新*/
                    if (distance < matrix[i][j]) {
                        /** 更新距离*/
                        matrix[i][j] = distance;
                        /** 更新前驱顶点*/
                        preVertexes[i][j] = preVertexes[k][j];
                    }
                }
            }
        }
    }

    /** 打印结果*/
    public void show() {
        for (int k = 0; k < matrix.length; k++) {
            /** 打印前驱顶点数组的一行*/
            for (int i = 0; i < matrix.length; i++) {
                System.out.print(vertexes[preVertexes[k][i]] + " ");
            }
            /** 打印邻接矩阵指定行数据*/
            for (int i = 0; i < matrix.length; i++) {
                System.out.print("(" + vertexes[k] + "到 " + vertexes[i] + "的最短路径是" + matrix[k][i] + ") ");
            }
            System.out.println();
        }
    }

}

输出:
A A A F G G A (A到 A的最短路径是0) (A到 B的最短路径是5) (A到 C的最短路径是7) (A到 D的最短路径是12) (A到 E的最短路径是6) (A到 F的最短路径是8) (A到 G的最短路径是2) 
B B A B G G B (B到 A的最短路径是5) (B到 B的最短路径是0) (B到 C的最短路径是12) (B到 D的最短路径是9) (B到 E的最短路径是7) (B到 F的最短路径是9) (B到 G的最短路径是3) 
C A C F C E A (C到 A的最短路径是7) (C到 B的最短路径是12) (C到 C的最短路径是0) (C到 D的最短路径是17) (C到 E的最短路径是8) (C到 F的最短路径是13) (C到 G的最短路径是9) 
G D E D F D F (D到 A的最短路径是12) (D到 B的最短路径是9) (D到 C的最短路径是17) (D到 D的最短路径是0) (D到 E的最短路径是9) (D到 F的最短路径是4) (D到 G的最短路径是10) 
G G E F E E E (E到 A的最短路径是6) (E到 B的最短路径是7) (E到 C的最短路径是8) (E到 D的最短路径是9) (E到 E的最短路径是0) (E到 F的最短路径是5) (E到 G的最短路径是4) 
G G E F F F F (F到 A的最短路径是8) (F到 B的最短路径是9) (F到 C的最短路径是13) (F到 D的最短路径是4) (F到 E的最短路径是5) (F到 F的最短路径是0) (F到 G的最短路径是6) 
G G A F G G G (G到 A的最短路径是2) (G到 B的最短路径是3) (G到 C的最短路径是9) (G到 D的最短路径是10) (G到 E的最短路径是4) (G到 F的最短路径是6) (G到 G的最短路径是0) 

• 演变过程图示

1. C-A-G(9)
2. C-A-B(12)
3. G-A-B(7) - 此时由于 G到B本来是3结果绕过A, 会导致变的更长就不会被更新

* 初始顶点间距离表: A作为中间顶点遍历得到更新后的距离表

* 初始顶点与前驱关系表: A作为中间顶点遍历一次得到更新后的前驱关系表

如果您觉得有帮助，欢迎点赞哦 ~ 谢谢!!