【运筹优化】最短路算法之Floyd算法 + Java代码实现_floyd最短路算法

一、Floyd算法简介

Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。

在计算机科学中，Floyd-Warshall算法是一种在具有正或负边缘权重（但没有负周期）的加权图中找到最短路径的算法。算法的单个执行将找到所有顶点对之间的最短路径的长度（加权）。

二、Floyd算法思想

2.1 路径矩阵

通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。
从图的带权邻接矩阵A=[a(i,j)] n×n开始，迭代地进行n次更新，即由矩阵D(0)=A，按一个公式，构造出矩阵D(1)；又用同样地公式由D(1)构造出D(2)；……；最后又用同样的公式由D(n-1)构造出矩阵D(n)。矩阵D(n)的i行j列元素便是i号顶点到j号顶点的最短路径长度，称D(n)为图的距离矩阵，同时还可引入一个后继节点矩阵path来记录两点间的最短路径。
采用松弛技术（松弛操作），对在i和j之间的所有其他点进行一次松弛。所以时间复杂度为O(n^3);

2.2 状态转移方程

其状态转移方程如下： map[i,j]:=min{map[i,k]+map[k,j],map[i,j]}；
map[i,j]表示i到j的最短距离，K是穷举i,j的断点，map[n,n]初值应该为0，或者按照题目意思来做。
当然，如果这条路没有通的话，还必须特殊处理，比如没有map[i,k]这条路。

三、Floyd算法 java代码

@Data
public class Floyd {
    double[][] distance;

    public Floyd(double[][] distance) {
        this.distance = distance;
    }

    public void solve() {
        double[][] cloneDistance = copy2DArr(distance);
        for (int i = 0; i < cloneDistance.length; i++) {
            for (int j = 0; j < cloneDistance.length; j++) {
                for (int k = 0; k < cloneDistance.length; k++) {
                    cloneDistance[j][k] = Math.min(cloneDistance[j][k], cloneDistance[j][i] + cloneDistance[i][k]);
                }
            }
        }
        for (double[] row : cloneDistance) {
            System.out.println(Arrays.toString(row));
        }
    }

    private double[][] copy2DArr(double[][] original) {
        double[][] arr = new double[original.length][original[0].length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = original[i].clone();
        }
        return arr;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

四、测试

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        final double N = 65535;
        double[][] distance = new double[][]{
                { 0, 5, 7, N, N, N, 2 },
                { 5, 0, N, 9, N, N, 3 },
                { 7, N, 0, N, 8, N, N },
                { N, 9, N, 0, N, 4, N },
                { N, N, 8, N, 0, 5, 4 },
                { N, N, N, 4, 5, 0, 6 },
                { 2, 3, N, N, 4, 6, 0 },
        };
        new Floyd(distance).solve();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

控制台输出：

[0.0, 5.0, 7.0, 12.0, 6.0, 8.0, 2.0]
[5.0, 0.0, 12.0, 9.0, 7.0, 9.0, 3.0]
[7.0, 12.0, 0.0, 17.0, 8.0, 13.0, 9.0]
[12.0, 9.0, 17.0, 0.0, 9.0, 4.0, 10.0]
[6.0, 7.0, 8.0, 9.0, 0.0, 5.0, 4.0]
[8.0, 9.0, 13.0, 4.0, 5.0, 0.0, 6.0]
[2.0, 3.0, 9.0, 10.0, 4.0, 6.0, 0.0]
1
2
3
4
5
6
7

五、优缺点分析

Floyd算法适用于APSP(All Pairs Shortest Paths，多源最短路径)，是一种动态规划算法，稠密图效果最佳，边权可正可负。

此算法简单有效，由于三重循环结构紧凑，对于稠密图，效率要高于执行|V|次Dijkstra算法，也要高于执行|V|次SPFA算法。

优点：容易理解，可以算出任意两个节点之间的最短距离，代码编写简单。

缺点：时间复杂度比较高，不适合计算大量数据。