Floyd-Warshall 算法概述

Floyd-Warshall算法是一种用于求解图中所有节点对之间最短路径的动态规划算法。该算法可以处理有向图或带有权重的无向图，并能够处理图中存在负权边的情况。Floyd-Warshall算法的时间复杂度为O(V^3)，其中V是节点的数量。

算法的基本思想是通过中间节点逐步更新节点对之间的最短路径信息。具体步骤如下：

1. 初始化： 创建一个二维数组 dist[][]，其中 dist[i][j] 表示节点 i 到节点 j 的最短路径长度。初始时，如果存在直接相连的边，则 dist[i][j] 等于这条边的权重，否则设置为无穷大。

2. 动态规划过程： 对于每一对节点 i 和 j，检查是否存在节点 k 使得从 i 到 k 再到 j 的路径比直接从 i 到 j 的路径更短。如果是，更新 dist[i][j] 为更短的路径长度。

3. 迭代： 重复上述步骤，对每一对节点进行检查和更新，直到找到所有节点之间的最短路径。

4. 结果： 最终，dist矩阵中的元素dist[i][j]表示从节点i到节点j的最短路径长度。

Floyd-Warshall算法适用于任意权重的图，包括有向图和带负权边的图。然而，它的时间复杂度相对较高，对于较大规模的图可能不太适用。在实际应用中，如果图是稀疏的（边的数量相对节点数较少），则其他算法如Dijkstra和Bellman-Ford可能更有效。

算法实现：

下面是一个简单的 C++ 实现：

#include <bits/stdc++.h>
using namespace std;
const int _MAX = 1e6 + 1;

void floydWarshall(int graph[][4], int V)    // 修正函数参数
{

    // 逐个节点进行中间节点的检查和更新
    for (int k = 0; k < V; k++)
    {
        for (int i = 0; i < V; i++)
        {
            for (int j = 0; j < V; j++)
            {
                // 如果从 i 到 k 再到 j 的路径比直接从 i 到 j 的路径短
                if (graph[i][k] != _MAX && graph[k][j] != _MAX &&
                        graph[i][k] + graph[k][j] < graph[i][j])
                {
                    graph[i][j] = graph[i][k] + graph[k][j];
                }
            }
        }
    }

    // 输出最短路径矩阵
    cout << "最短路径矩阵：" << endl;
    for (int i = 0; i < V; i++)
    {
        for (int j = 0; j < V; j++)
        {
            if (graph[i][j] == _MAX)
            {
                cout << "_MAX ";
            }
            else
            {
                cout << graph[i][j] << " ";
            }
        }
        cout << endl;
    }
}

int main()
{
    int V = 4;
    int graph[4][4] =    // 修正图的初始化
    {
        {0, 5, _MAX, 10},
        {_MAX, 0, 3, _MAX},
        {_MAX, _MAX, 0, 1},
        {_MAX, _MAX, _MAX, 0}
    };

    floydWarshall(graph, V);

    return 0;
}

此代码中，graph 表示图的邻接矩阵，其中 INT_MAX 表示两节点之间没有直接连接的边。算法会输出最短路径矩阵，显示每一对节点之间的最短路径长度。