【图论】Floyd-Warshall 算法

Floyd-Warshall算法详解
原创 已于 2025-11-15 11:29:42 修改 · 1k 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#图论 #算法 #c++

于 2025-08-25 23:36:57 首次发布

Floyd-Warshall 算法（简称 Floyd 算法）是一种用于求解所有顶点对之间的最短路径的经典动态规划算法。它适用于带权有向图或无向图，可以处理正权边、负权边，但不能处理包含负权回路（负权环）的图。

一、算法目标

给定一个带权图 G=(V,E)G = (V, E)G=(V,E)，其中 VVV 是顶点集合，EEE 是边集合，每条边有权重（可以为负）。Floyd 算法的目标是计算出图中任意两个顶点 iii 和 jjj 之间的最短路径长度，并可选择性地记录下路径本身。

二、核心思想：动态规划

Floyd 算法的核心思想是动态规划。它通过逐步引入“中间顶点”来更新任意两点间的最短距离。

1. 定义状态

定义 dist[i][j][k] 为：从顶点 iii 到顶点 jjj，且路径中只允许使用前 kkk 个顶点作为中间顶点时的最短路径长度。

这里的“前 kkk 个顶点”通常指顶点编号为 000 到 k−1k-1k−1（如果顶点从 0 开始编号）。

2. 状态转移方程

考虑是否使用第 kkk 个顶点（即顶点 k−1k-1k−1）作为中间点：

  • 不使用顶点 k−1k-1k−1 作为中间点：那么最短路径就是 dist[i][j][k-1]。
  • 使用顶点 k−1k-1k−1 作为中间点：路径可以分解为 i→k−1i \to k-1i→k−1 和 k−1→jk-1 \to jk−1→j，这两段路径也都只允许使用前 k−1k-1k−1 个顶点作为中间点，因此长度为 dist[i][k-1][k-1] + dist[k-1][j][k-1]。

取两者中的最小值：

dist[i][j][k]=min⁡(dist[i][j][k−1], dist[i][k−1][k−1]+dist[k−1][j][k−1]) \text{dist}[i][j][k] = \min(\text{dist}[i][j][k-1],\ \text{dist}[i][k-1][k-1] + \text{dist}[k-1][j][k-1]) dist[i][j][k]=min(dist[i][j][k−1], dist[i][k−1][k−1]+dist[k−1][j][k−1])

3. 空间优化：滚动数组

注意到 dist[i][j][k] 只依赖于 dist[...][...][k-1]，因此我们可以省略第三维，直接在二维数组上原地更新。即：

dist[i][j]=min⁡(dist[i][j], dist[i][k]+dist[k][j]) \text{dist}[i][j] = \min(\text{dist}[i][j],\ \text{dist}[i][k] + \text{dist}[k][j]) dist[i][j]=min(dist[i][j], dist[i][k]+dist[k][j])

这里 k 是当前允许使用的最大编号的中间顶点。我们按 kkk 从 000 到 n−1n-1n−1 的顺序进行迭代。

三、算法步骤

1. 初始化距离矩阵 dist：

  • 对于每对顶点 (i,j)(i, j)(i,j)：
    • 如果 i=ji = ji=j，则 dist[i][j] = 0（到自身的距离为 0）。
    • 如果存在从 iii 到 jjj 的边，权重为 www，则 dist[i][j] = w。
    • 否则，dist[i][j] = \infty（表示不可达）。

2. 三重循环迭代：

  • 外层循环 kkk：从 000 到 n−1n-1n−1，表示当前允许使用的中间顶点是 kkk。
    • 中层循环 iii：从 000 到 n−1n-1n−1，表示起点。
    • 内层循环 jjj：从 000 到 n−1n-1n−1，表示终点。
    • 更新：dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

3. （可选）路径重建：

  • 为了能够输出最短路径本身，需要维护一个 next 矩阵。
    • next[i][j] 存储从 iii 到 jjj 的最短路径上，iii 的下一个顶点。
    • 在初始化时，如果存在边 i→ji \to ji→j，则 next[i][j] = j；否则为 nullptr 或 -1。
    • 在更新 dist[i][j] 时，如果通过 kkk 的路径更短，则更新 next[i][j] = next[i][k]。

4. （可选）负权环检测：

  • 算法结束后，检查 dist[i][i] < 0 的顶点 iii。如果存在，则说明图中存在负权环（因为从 iii 到 iii 的路径长度为负，意味着存在一个负权环）。

四、 算法复杂度

  • 时间复杂度：O(V3)O(V^3)O(V3)。三重循环，每层循环 VVV 次。
  • 空间复杂度：O(V2)O(V^2)O(V2)。主要存储距离矩阵 dist（和 next 矩阵）。

五、 优缺点

  • 优点：
    • 代码简洁，易于实现。
    • 可以求出所有顶点对的最短路径。
    • 可以处理负权边。
  • 缺点：
    • 时间复杂度较高，对于稀疏图不如 Dijkstra 或 Bellman-Ford 高效。
    • 不能处理负权环（会得到错误结果）。

六、C++ 实现

下面是一个完整的 C++ 实现，包含距离计算、路径重建和负权环检测。

#include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
#include <stack>

using namespace std;

// 常量：表示无穷大（不可达）
const int INF = INT_MAX / 2; // 使用 INT_MAX/2 防止加法溢出

class FloydWarshall {
private:
    int n; // 顶点数量
    vector<vector<int>> dist; // 距离矩阵
    vector<vector<int>> next; // 路径重建矩阵：next[i][j] 表示 i 到 j 最短路径上 i 的下一个顶点
    bool hasNegativeCycle; // 标记是否存在负权环

public:
    // 构造函数
    FloydWarshall(int vertices) : n(vertices), hasNegativeCycle(false) {
        // 初始化距离矩阵
        dist.assign(n, vector<int>(n, INF));
        for (int i = 0; i < n; ++i) {
            dist[i][i] = 0; // 自身到自身的距离为 0
        }

        // 初始化 next 矩阵
        next.assign(n, vector<int>(n, -1)); // -1 表示无下一个顶点
    }

    // 添加有向边
    void addEdge(int from, int to, int weight) {
        // 注意：这里假设没有重边，如果有重边，应保留最小权重
        if (weight < dist[from][to]) {
            dist[from][to] = weight;
            next[from][to] = to; // from 到 to 的下一个顶点是 to
        }
    }

    // 执行 Floyd-Warshall 算法
    void computeShortestPaths() {
        // 三重循环：k 是中间顶点，i 是起点，j 是终点
        for (int k = 0; k < n; ++k) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    // 避免 INF 相加导致溢出
                    if (dist[i][k] < INF && dist[k][j] < INF) {
                        if (dist[i][j] > dist[i][k] + dist[k][j]) {
                            dist[i][j] = dist[i][k] + dist[k][j];
                            next[i][j] = next[i][k]; // 更新路径：i 到 j 的下一个点是 i 到 k 的下一个点
                        }
                    }
                }
            }
        }

        // 检测负权环：检查 dist[i][i] < 0
        for (int i = 0; i < n; ++i) {
            if (dist[i][i] < 0) {
                hasNegativeCycle = true;
                break;
            }
        }
    }

    // 查询从 i 到 j 的最短距离
    int getDistance(int i, int j) const {
        if (hasNegativeCycle) {
            cout << "图中存在负权环，结果无效！" << endl;
            return INF;
        }
        if (dist[i][j] == INF) {
            return INF; // 不可达
        }
        return dist[i][j];
    }

    // 获取从 i 到 j 的最短路径（顶点序列）
    vector<int> getPath(int i, int j) const {
        if (hasNegativeCycle) {
            cout << "图中存在负权环，路径无效！" << endl;
            return {};
        }
        if (dist[i][j] == INF) {
            cout << "从 " << i << " 到 " << j << " 不可达。" << endl;
            return {};
        }

        vector<int> path;
        path.push_back(i);
        // 使用 next 矩阵重建路径
        while (i != j) {
            i = next[i][j];
            if (i == -1) { // 理论上不应发生，因为已检查可达
                cout << "路径重建错误！" << endl;
                return {};
            }
            path.push_back(i);
        }
        return path;
    }

    // 打印所有顶点对的最短距离
    void printAllDistances() const {
        if (hasNegativeCycle) {
            cout << "图中存在负权环，无法打印有效距离。" << endl;
            return;
        }

        cout << "所有顶点对之间的最短距离：" << endl;
        cout << "     ";
        for (int j = 0; j < n; ++j) {
            cout << "   " << j << "   ";
        }
        cout << endl;

        for (int i = 0; i < n; ++i) {
            cout << "  " << i << " | ";
            for (int j = 0; j < n; ++j) {
                if (dist[i][j] == INF) {
                    cout << " INF  ";
                } else {
                    cout << " " << dist[i][j] << " ";
                    if (dist[i][j] < 10) cout << " "; // 对齐
                }
            }
            cout << endl;
        }
    }

    // 打印从 i 到 j 的最短路径
    void printPath(int i, int j) const {
        auto path = getPath(i, j);
        if (path.empty()) return;

        cout << "从 " << i << " 到 " << j << " 的最短路径: ";
        for (size_t idx = 0; idx < path.size(); ++idx) {
            cout << path[idx];
            if (idx < path.size() - 1) cout << " -> ";
        }
        cout << " (距离: " << getDistance(i, j) << ")" << endl;
    }

    // 检查是否存在负权环
    bool hasNegativeCycleDetected() const {
        return hasNegativeCycle;
    }
};

// 测试函数
int main() {
    // 示例 1: 一个简单的正权图
    cout << "=== 示例 1: 正权图 ===" << endl;
    FloydWarshall fw1(4);

    // 添加边 (from, to, weight)
    fw1.addEdge(0, 1, 5);
    fw1.addEdge(0, 3, 10);
    fw1.addEdge(1, 2, 3);
    fw1.addEdge(2, 3, 1);
    fw1.addEdge(3, 1, 2); // 注意这个反向边

    fw1.computeShortestPaths();

    if (fw1.hasNegativeCycleDetected()) {
        cout << "检测到负权环！" << endl;
    } else {
        fw1.printAllDistances();
        fw1.printPath(0, 3);
        fw1.printPath(0, 2);
    }

    cout << "\n" << endl;

    // 示例 2: 包含负权边但无负权环的图
    cout << "=== 示例 2: 负权边图（无负权环）===" << endl;
    FloydWarshall fw2(3);

    fw2.addEdge(0, 1, 4);
    fw2.addEdge(0, 2, 3);
    fw2.addEdge(1, 2, -2); // 负权边
    fw2.addEdge(2, 1, 1);  // 另一条边

    fw2.computeShortestPaths();

    if (fw2.hasNegativeCycleDetected()) {
        cout << "检测到负权环！" << endl;
    } else {
        fw2.printAllDistances();
        fw2.printPath(0, 1);
        fw2.printPath(0, 2);
    }

    cout << "\n" << endl;

    // 示例 3: 包含负权环的图
    cout << "=== 示例 3: 负权环图 ===" << endl;
    FloydWarshall fw3(3);

    fw3.addEdge(0, 1, 1);
    fw3.addEdge(1, 2, -3);
    fw3.addEdge(2, 0, 1); // 形成环 0->1->2->0，权重和为 1-3+1 = -1 < 0

    fw3.computeShortestPaths();

    if (fw3.hasNegativeCycleDetected()) {
        cout << "检测到负权环！" << endl;
        // 此时距离矩阵可能无效
        cout << "顶点 0 到自身的距离: " << fw3.getDistance(0, 0) << endl; // 应为负数
    } else {
        fw3.printAllDistances();
    }

    return 0;
}

代码说明

  1. INF 常量：使用 INT_MAX / 2 而不是 INT_MAX，是为了在 dist[i][k] + dist[k][j] 计算时防止整数溢出（如果 dist[i][k] 或 dist[k][j] 是 INT_MAX，相加会溢出）。
  2. addEdge 函数：处理重边，只保留最小权重的边。
  3. computeShortestPaths：核心三重循环，包含溢出检查和负权环检测。
  4. next 矩阵：用于路径重建。next[i][j] 指向从 iii 到 jjj 的最短路径上 iii 的直接后继。
  5. getPath 函数：利用 next 矩阵，从起点开始，一步步跳到下一个顶点，直到到达终点，构建完整路径。
  6. 负权环检测：在算法结束后检查 dist[i][i] < 0。

七、总结

Floyd-Warshall 算法是一个优雅而强大的算法，特别适合于需要频繁查询任意两点间最短距离的场景，或者顶点数量较少的图。虽然其 O(V3)O(V^3)O(V3) 的时间复杂度在大图上不占优势，但其实现简单、逻辑清晰，是图论中最基础和重要的算法之一。

最短路径算法（Dijkstra算法、Floyd-Warshall算法）
LX的专栏
04-18 1484
最短路径算法是解决图论中节点之间最短路径问题的经典算法。以下是两种常见的最短路径算法：Dijkstra算法和Floyd-Warshall算法。
（4-1）Floyd-Warshall算法：Floyd-Warshall算法简介
码农三叔
07-10 877
Floyd-Warshall算法是一种动态规划算法，用于解决所有节点对之间的最短路径问题。Floyd-Warshall通过遍历所有节点，检查是否存在更短的路径来更新距离矩阵，并最终确定所有节点对之间的最短路径长度。在实际应用中，Floyd-Warshall算法的优点是能够找到所有节点对之间的最短路径，并且适用于带有负权边但不带负权环路的图。缺点是因为其时间复杂度较高，所以对于大型图而言可能不太适用。
Floyd-Warshall算法
Summen95的博客
01-29 756
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
floyd-warshall算法
dxx_111的博客
08-21 3696
算法distancepathoutputcini  Floyd-Warshall算法，简称Floyd算法，用于求解任意两点间的最短距离，时间复杂度为O(n^3)。我们平时所见的Floyd算法的一般形式如下： 1 void Floyd(){ 2     int i,j,k; 3     for(k=1;kn;k++) 4         for(i=1;in;i++) 5
Floyd-Warshall 算法
Become hunger become strong
11-18 662
//Floyd-Warshall 算法 -> 来自啊哈算法 #include <stdio.h> int main() { int e[10][10],n,m,t1,t2,t3; int inf = 99999999; scanf("%d %d",&n,&m);//定点数和边数 for(int i = 1;i <= n;i++) for(int j
图论中最短路径Floyd-Warshall算法的Python实现及其应用场景 - Floyd-Warshall算法
最新发布
08-09
Floyd-Warshall算法用于求解图中任意两点之间的最短路径的方法。首先解释了该算法相较于其他最短路径算法的独特之处，即它可以处理带权重的有向图或多源最短路径问题。随后给出了Python语言的具体实现代码，重点在于...
图论------弗洛伊德(Floyd-Warshall)算法
markingyi的博客
08-10 1087
题目描述：
基于Floyd-Warshall算法实现高效求解最短路径代码技术解析,Floyd-Warshall算法：高效求解最短距离路径代码实现,floyd算法求最小距离代码 ,Floyd算法; 最小距离; 代
03-03
Floyd-Warshall算法是一种用于在加权...Floyd-Warshall算法是图论和计算机网络中一个非常重要的算法，它不仅提供了一种求解最短路径问题的有效手段，而且其动态规划的思想对于解决其他类型的问题也有着重要的启示作用。
floyd-warshall算法（c++）
11-14
使用c++编写的floyd-warshall算法，还有《算法导论》上的另外一种动态规划解法。
Floyd-Warshal算法
小渣渣的博客
08-15 1017
先来简单分析下,由于矩阵中对角线上的元素始终为0,因此以k为中间点时,从上一个矩阵到下一个矩阵变化时,矩阵的第k行,第k列和对角线上的元素是不发生改变的（对角线上都是0，因为一个顶点到自己的距离就是0，一直不变；而当k为中间点时，k到其他顶点（第k行）和其他顶点到k（第k列）的距离是不变的）。 因此每一步中我们只需要判断4*4-3*4+2=6个元素是否发生改变即可,也就是要判断既不在第k行第k列...
算法：Floyd-Warshall
小猪快跑
01-22 1020
算法：Floyd-Warshall
算法——Floyd-Warshall算法
m0_60697583的博客
04-17 294
下面的示例中，使用c++简单实现了Floyd-Warshall算法。首先，我们用邻接矩阵表示图，并初始化所有顶点对之间的最短路径。然后，我们通过嵌套的循环来逐步更新最短路径矩阵，直到找到所有顶点对的最短路径。Floyd-Warshall算法是一种用于解决图中所有顶点对之间最短路径的动态规划算法。它可以处理有向图或无向图，以及负权边（但不能处理负权回路）。Floyd-Warshall算法采用了动态规划的思想，通过逐步更新所有顶点对之间的最短路径来求解问题。
Floyd-Warshall[弗洛依德]算法
WatermelonMk的博客
10-24 6065
1.定义概览 Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。 2.算法原理 Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所
Floyd-Warshall算法应用与最短路径实现解析
总结来说，Floyd-Warshall算法是图论中一个非常重要的算法，它能够高效地计算出加权无向图中所有顶点对的最短路径。它在实现上通常需要优化技巧，比如Dancing Links，来应对大规模数据问题。此外，它在多个实际应用...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值