Floyd算法：动态规划解最短路径

Floyd 算法概述

Floyd 算法是一种用于求解图中所有顶点对之间最短路径的动态规划算法。该算法由 Robert Floyd 在 1962 年提出，适用于有向图或无向图，允许边权为负值，但不能存在负权回路。Floyd 算法的核心思想是通过逐步优化路径来更新最短距离矩阵。

算法核心思想

Floyd 算法通过三重循环动态更新距离矩阵。假设图中有 ( n ) 个顶点，算法的基本思路是：对于每一对顶点 ( (i, j) )，检查是否存在一个中间顶点 ( k )，使得从 ( i ) 到 ( j ) 的路径经过 ( k ) 后路径更短。如果是，则更新距离矩阵中的值。

算法步骤

1. 初始化距离矩阵

   创建一个 ( n \times n ) 的矩阵 ( D )，其中 ( D[i][j] ) 表示顶点 ( i ) 到顶点 ( j ) 的直接距离。如果 ( i ) 和 ( j ) 之间没有直接边，则 ( D[i][j] = \infty )。对于 ( i = j )，( D[i][j] = 0 )。

2. 动态更新距离矩阵

   对于每一个中间顶点 ( k )（从 1 到 ( n )），遍历所有顶点对 ( (i, j) )，检查是否存在通过 ( k ) 的更短路径。即：

   D\[i\]\[j\] = \\min(D\[i\]\[j\], D\[i\]\[k\] + D\[k\]\[j\])

   如果 ( D[i][k] + D[k][j] ) 比当前的 ( D[i][j] ) 小，则更新 ( D[i][j] )。

3. 输出最终结果

   完成所有中间顶点的遍历后，矩阵 ( D ) 中的 ( D[i][j] ) 即为顶点 ( i ) 到顶点 ( j ) 的最短距离。

算法实现

以下是 Floyd 算法的 C++ 实现代码：

#include <iostream>
#include <vector>
#include <climits>

using namespace std;

const int INF = INT_MAX;

void floydWarshall(vector<vector<int>>& graph, int n) {
    vector<vector<int>> dist(n, vector<int>(n));

    // 初始化距离矩阵
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            dist[i][j] = graph[i][j];
        }
    }

    // 动态更新距离矩阵
    for (int k = 0; k < n; ++k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }

    // 输出最短距离矩阵
    cout << "最短距离矩阵：" << endl;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (dist[i][j] == INF) {
                cout << "INF ";
            } else {
                cout << dist[i][j] << " ";
            }
        }
        cout << endl;
    }
}

int main() {
    int n = 4;
    vector<vector<int>> graph = {
        {0, 5, INF, 10},
        {INF, 0, 3, INF},
        {INF, INF, 0, 1},
        {INF, INF, INF, 0}
    };

    floydWarshall(graph, n);

    return 0;
}

算法复杂度分析

Floyd 算法的时间复杂度为 ( O(n^3) )，其中 ( n ) 是图中顶点的数量。这是因为算法需要三重循环遍历所有顶点对和中间顶点。空间复杂度为 ( O(n^2) )，用于存储距离矩阵。

算法正确性证明

Floyd 算法的正确性基于动态规划的最优子结构性质。假设 ( D_k[i][j] ) 表示从顶点 ( i ) 到顶点 ( j ) 且中间顶点编号不超过 ( k ) 的最短路径长度。算法的递推关系为：

D_k\[i\]\[j\] = \\min(D_{k-1}\[i\]\[j\], D_{k-1}\[i\]\[k\] + D_{k-1}\[k\]\[j\])

通过逐步优化，最终得到的 ( D_n[i][j] ) 即为全局最短路径。

算法应用场景

Floyd 算法适用于以下场景：

1. 需要求解图中所有顶点对之间的最短路径。
2. 图的规模较小（顶点数不超过几百），因为 ( O(n^3) ) 的复杂度在大规模图中效率较低。
3. 图中允许存在负权边，但不能有负权回路。

算法优缺点

优点：

1. 可以处理负权边（但不能有负权回路）。
2. 代码实现简单，易于理解。
3. 适用于稠密图，尤其是需要多次查询任意两点间最短路径的场景。

缺点：

1. 时间复杂度较高，不适用于大规模图。
2. 空间复杂度较高，需要存储 ( n \times n ) 的矩阵。

算法优化

虽然 Floyd 算法的时间复杂度难以进一步降低，但在某些情况下可以通过以下方式优化：

1. 提前终止：如果在某次迭代中距离矩阵未发生任何更新，可以提前终止算法。
2. 并行化：利用多线程或 GPU 加速三重循环的计算。

与其他最短路径算法的比较

1. Dijkstra 算法：

   • 适用于单源最短路径问题，时间复杂度为 ( O((V + E) \log V) )（使用优先队列）。
   • 不能处理负权边。
   • 在稀疏图中效率高于 Floyd 算法。

2. Bellman-Ford 算法：

   • 适用于单源最短路径问题，可以检测负权回路。
   • 时间复杂度为 ( O(VE) )，效率低于 Dijkstra 算法。

3. Floyd 算法：

   • 适用于所有顶点对的最短路径问题。
   • 可以处理负权边（但不能有负权回路）。
   • 在稠密图中表现较好。

负权回路检测

Floyd 算法可以通过检查距离矩阵的主对角线来检测负权回路。如果在算法结束后，存在 ( D[i][i] < 0 )，则说明图中存在负权回路。

路径重建

如果需要记录最短路径的具体路径，可以引入一个路径矩阵 ( P )，其中 ( P[i][j] ) 表示从 ( i ) 到 ( j ) 的最短路径的中间顶点。以下是路径重建的实现：

void floydWarshallWithPath(vector<vector<int>>& graph, int n) {
    vector<vector<int>> dist(n, vector<int>(n));
    vector<vector<int>> next(n, vector<int>(n, -1));

    // 初始化距离矩阵和路径矩阵
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            dist[i][j] = graph[i][j];
            if (graph[i][j] != INF && i != j) {
                next[i][j] = j;
            }
        }
    }

    // 动态更新距离矩阵和路径矩阵
    for (int k = 0; k < n; ++k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                    next[i][j] = next[i][k];
                }
            }
        }
    }

    // 输出最短路径
    cout << "最短路径：" << endl;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && next[i][j] != -1) {
                cout << "从 " << i << " 到 " << j << " 的路径：";
                int u = i;
                cout << u;
                while (u != j) {
                    u = next[u][j];
                    cout << " -> " << u;
                }
                cout << endl;
            }
        }
    }
}

实际应用示例

以下是一个具体的图例，展示 Floyd 算法的运行过程：

初始图：

• 顶点：0, 1, 2, 3
• 边权：
  • (0, 1): 5
  • (0, 3): 10
  • (1, 2): 3
  • (2, 3): 1

初始距离矩阵： [ \begin{bmatrix} 0 & 5 & \infty & 10 \ \infty & 0 & 3 & \infty \ \infty & \infty & 0 & 1 \ \infty & \infty & \infty & 0 \ \end{bmatrix} ]

运行 Floyd 算法后的距离矩阵： [ \begin{bmatrix} 0 & 5 & 8 & 9 \ \infty & 0 & 3 & 4 \ \infty & \infty & 0 & 1 \ \infty & \infty & \infty & 0 \ \end{bmatrix} ]

总结

Floyd 算法是一种经典的最短路径算法，适用于求解所有顶点对之间的最短路径问题。虽然其时间复杂度较高，但在小规模图或需要频繁查询任意两点间最短路径的场景中表现良好。算法的实现简单，且能够处理负权边，是一种非常实用的工具。