Floyd-Warshall算法C++实现

探索 Floyd-Warshall 算法——解决全源最短路径问题

什么是 Floyd-Warshall 算法？

• Floyd-Warshall 算法是一种用于解决图论中全源最短路径问题的经典动态规划算法。它可以在一个具有 $n$个顶点的加权有向图中,找出任意两个顶点之间的最短路径长度。
• 与单源最短路径问题不同,全源最短路径问题需要找出图中所有顶点对之间的最短路径长度。Floyd-Warshall算法能够有效地解决这一问题,其时间复杂度仅为
  $O(n^3)$。

算法原理

Floyd-Warshall 算法的基本思路如下:

1. 初始化：构建一个 $n\times n$ 的二维数组 dist，其中 dist[i][j] 表示顶点 $i$ 到顶点 $j$ 的最短路径长度。初始时,dist[i][j] 等于图中边 $(i,j)$ 的权重,如果不存在该边则设为正无穷。

2. 动态规划：进行 $n$ 轮迭代更新,每轮迭代考虑一个中间顶点 $k$。在第 $k$ 轮迭代中,对于任意顶点 $i$ 和 $j$，如果存在从 $i$ 到 $k$ 再到 $j$ 的路径且比直接从 $i$ 到 $j$ 的路径更短,则更新 dist[i][j]
   的值。

3. 结果输出：经过 $n$ 轮迭代后,dist[i][j] 就是顶点 $i$ 到顶点 $j$ 的最短路径长度。

提个问题，不知道你有没有想过为什么Floyd-Warshall 算法会需要三重循环？

Floyd-Warshall 算法之所以需要三重循环,是因为它采用了一种称为"中间顶点"的动态规划策略来求解全源最短路径问题。具体来说:

1. 第一层循环：

   • 遍历所有可能的中间顶点 $k$。
   • 这是因为 Floyd-Warshall 算法需要考虑引入新的中间顶点 $k$ 后,是否能够找到更短的路径。

2. 第二层循环：

   • 遍历所有可能的起点 $i$。
   • 这是因为对于每个中间顶点 $k$,我们需要检查从所有起点 $i$ 到该中间顶点 $k$ 的路径长度。

3. 第三层循环：

   • 遍历所有可能的终点 $j$。
   • 这是因为对于每个起点 $i$ 和中间顶点 $k$,我们需要检查从该中间顶点 $k$ 到所有终点 $j$ 的路径长度。

这三层循环的嵌套体现了 Floyd-Warshall 算法的核心思想：

• 对于任意两个顶点 $i$ 和 $j$,如果存在一个中间顶点 $k$ 使得从 $i$ 到 $k$ 再到 $j$ 的路径更短,则更新 $i$ 到 $j$ 的最短路径长度。
• 通过枚举所有可能的中间顶点 $k$,并检查从 $i$ 到 $j$ 经过 $k$ 是否更短,最终可以求出任意两个顶点之间的最短路径长度。

这种"中间顶点"的动态规划思想是 Floyd-Warshall算法的核心,也是它需要三重循环的关键原因。三重循环的嵌套结构确保了算法能够完整地考虑所有可能的路径组合,从而得出正确的全源最短路径结果。

Floyd-Warshall算法的具体C++ 实现

为了便于大家的理解，下面给出关于Floyd-Warshall算法的具体C++ 实现，包括图的初始化、算法实现以及结果输出。

#include <iostream>
#include <vector>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max(); // 定义无穷大

// 图的结构体，包含邻接矩阵表示
struct Graph {
    int vertices;
    vector<vector<int>> dist; // 邻接矩阵，存储边的权重

    // 构造函数
    Graph(int v) : vertices(v), dist(v, vector<int>(v, INF)) {
        for (int i = 0; i < v; i++) {
            dist[i][i] = 0; // 每个顶点到自身的距离为0
        }
    }

    // 添加边
    void addEdge(int u, int v, int w) {
        dist[u][v] = w;
    }
};

// Floyd-Warshall 算法
void floydWarshall(Graph& graph) {
    int V = graph.vertices;
    vector<vector<int>> d = graph.dist; // 使用图的初始距离矩阵

    // 三重循环更新所有顶点对之间的最短路径
    for (int k = 0; k < V; k++) {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                if (d[i][k] != INF && d[k][j] != INF && d[i][k] + d[k][j] < d[i][j]) {
                    d[i][j] = d[i][k] + d[k][j];
                }
            }
        }
    }

    // 打印结果
    cout << "Shortest distances between every pair of vertices:" << endl;
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (d[i][j] == INF) {
                cout << "INF ";
            } else {
                cout << d[i][j] << " ";
            }
        }
        cout << endl;
    }
}

int main() {
    Graph g(4);
    g.addEdge(0, 1, 5);
    g.addEdge(0, 3, 10);
    g.addEdge(1, 2, 3);
    g.addEdge(2, 3, 1);

    floydWarshall(g);

    return 0;
}

代码说明：

1. 数据结构：使用 vector<vector<int>> 来表示图的邻接矩阵，其中每个元素代表一个顶点到另一个顶点的边的权重。
2. 图的初始化：
   • 构造函数中初始化邻接矩阵的大小，并将所有值设为 INF，表示无连接。
   • 对角线上的值设为0，表示顶点到自身的距离为0。
   • 通过 addEdge 函数向图中添加边。
3. Floyd-Warshall 算法实现：
   • 使用三层循环迭代，每次考虑顶点 k 作为可能的中间点，更新所有顶点对 (i, j) 的最短路径。
   • 如果通过顶点 k 可以得到更短的路径，则更新距离矩阵。
4. 输出：打印出所有顶点对之间的最短距离，如果某个顶点对之间没有路径，则显示 INF。

算法复杂度分析

1. Floyd-Warshall 算法的时间复杂度为 $O(n^3)$,其中 $n$ 是图中顶点的数量。这是因为算法需要进行 $n$轮迭代,每轮迭代需要遍历 $n\times n$ 个顶点对。
2. 空间复杂度为 $O(n^2)$,因为需要存储 $n\times n$ 的距离矩阵 dist。
3. 与 Dijkstra 算法相比，Floyd-Warshall 算法虽然时间复杂度较高，但它可以同时计算出所有顶点对之间的最短路径长度，而Dijkstra
   算法只能求解单源最短路径问题。因此，当需要计算全源最短路径时,Floyd-Warshall 算法通常是更好的选择。

应用场景

Floyd-Warshall算法的一些主要应用场景包括：

1. 网络路由：在计算机网络中,Floyd-Warshall 算法可用于计算任意两个节点之间的最短路径,从而优化网络路由。

2. 交通规划：在交通网络中,Floyd-Warshall 算法可用于计算任意两个位置之间的最短路径,为交通规划提供依据。

3. 社交网络分析：在社交网络中,Floyd-Warshall 算法可用于计算任意两个用户之间的最短路径,分析用户之间的关系。

4. 电路设计：在电路设计中,Floyd-Warshall 算法可用于寻找电路中任意两点之间的最短连接路径。

重要注意事项

• 算法复杂度：Floyd-Warshall 算法的时间复杂度是 O(V^3)，其中 V 是顶点的数量，因为算法需要三重循环来计算最短路径。
• 负权重环：此算法不能处理包含负权重环的图。如果需要处理负权重环的情况，可以考虑使用 Bellman-Ford 算法，并在其中检测负权重环。
• 内存使用: 由于使用了二维数组存储所有顶点对之间的最短路径，其空间复杂度为 O(V^2)。

通过上面详细的代码和说明，希望可以帮助你理解 Floyd-Warshall 算法的基本实现方式和原理，以及如何在 C++ 中实现它。