Floyd算法

概述

Floyd算法，也称为Floyd-Warshall算法，是一种经典的动态规划算法，用于解决任意两点间的最短路径问题，特别是在有向图或负权图中。之前介绍的Dijkstra算法、Bellman-Ford算法、SPFA算法都是单源最短路，即只能有一个起点。而Floyd算法可以求多个起点到多个终点的多条最短路径。

Floyd算法对边的权值正负没有要求，都可以处理。

算法思想

Floyd算法的基本思想是通过不断更新顶点间的最短路径来逐步逼近最终的最短路径。算法使用一个二维数组来记录顶点间的最短路径长度。在每一步迭代中，算法检查是否存在一个更短的路径，如果存在，则更新数组的值。最终，数组中存储的就是所有顶点对之间的最短路径长度。

算法步骤

1. 初始化：将图的邻接矩阵作为初始状态，其中矩阵的元素表示从节点i到节点j的直接距离。如果节点i和节点j之间没有直接连接，则该元素设置为无穷大。对角线上的元素表示自己到自己的距离，需要设置为0。
2. 迭代更新：通过三重循环，依次将每个节点作为中转节点，更新所有节点对之间的最短路径。状态转移方程为：dp[i][j] = min⁡(dp[i][j], dp[i][k] + dp[k][j])，其中k为当前中转节点。
3. 结果输出：经过n次迭代后，矩阵中的元素即为从节点i到节点j的最短路径长度。

这个所谓的状态转移，其实就是SPFA算法中的松弛操作。将k作为中转节点，看一下从i经过k再到j是否会比从i直接到j近一些。

因此，三重循环的最外层循环枚举中转节点。里面两重循环针对当前中转节点，遍历整个图来更新最短距离。

代码实现

给定一个 n 个点，m 条有向边的带非负权图，求该图中任意两点之间的最短距离。

输入格式

第一行为两个正整数n, m。第二行起m行，每行三个非负整数u, v, w，表示从u到v有一条权值为w的无向边。

输出格式

输出一个n*n的邻接矩阵，表示任意两点之间的最短距离

输入样例

4 6
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

输出样例

0 2 4 3
2 0 2 1
4 2 0 3
3 1 3 0

通过代码：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 10001;
int graph[N][N]; // 存图
int n, m;        // n个节点，m条边

void printGraph()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
            cout << graph[i][j] << " ";
        cout << endl;
    }
}

int main()
{
    memset(graph, 0x3f, sizeof(graph));
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        graph[i][i] = 0; // 对角线上的距离设置为0

    for (int i = 0; i < m; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        graph[u][v] = w;
        graph[v][u] = w; // 无向图
    }
    for (int k = 1; k <= n; k++) // 遍历中转节点
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j]);
    printGraph();
    return 0;
}