佛洛依德算法详解

佛洛依德算法详解

佛洛依德算法（Floyd-Warshall Algorithm）和迪杰斯特拉算法（Dijkstra’s Algorithm）都是用于解决图的最短路径问题的算法，但它们有一些关键的区别。

与迪杰斯特拉算法对比

佛洛依德算法：用于计算图中所有节点对之间的最短路径。
迪杰斯特拉算法：用于计算从一个源节点到其他所有节点的最短路径。

佛洛依德算法：具有较高的时间复杂度，通常为O(V^3)，其中V是节点的数量。
迪杰斯特拉算法：在正常情况下，时间复杂度为O(V^2)，但使用优先队列（堆）实现时可以优化到O((V+E)logV)，其中E是边的数量。

佛洛依德算法：适用于稠密图，即边的数量相对较大的情况。
迪杰斯特拉算法：适用于稀疏图，即边的数量相对较小的情况。

佛洛依德算法：能够处理带有负权边的图。
迪杰斯特拉算法：对于带有负权边的图，可能会产生不正确的结果。

佛洛依德算法：基于动态规划，通过中间节点来更新路径。
迪杰斯特拉算法：基于贪心算法，每次选择当前最短路径的节点进行扩展。

总体而言，选择使用佛洛依德算法还是迪杰斯特拉算法取决于具体的问题和图的特性。如果图较小或者需要计算所有节点对之间的最短路径，可以考虑使用佛洛依德算法。如果图较大且只需计算从一个源节点到其他节点的最短路径，迪杰斯特拉算法可能更为高效。

存图

存图请参考上一篇介绍迪杰斯特拉算法的博客：https://blog.csdn.net/KK_2018/article/details/135198924

原理

设置一个dist数组，dist[i][j]表示从节点i到节点j的最短路径距离，dist先初始化，如果节点i到j存在直达路径，则将dist[i][j]初始化为路径值，否则初始化为无穷大（INF），然后依次将每个节点设置为从节点i到节点j的中间节点，如果加入中间节点会导致dist[i][j]变小，就更新dist[i][j]的值为这个更小的值，就核心原理就是一个公式：
$$dist[i][j]=dist[i][j]>dist[i][k]+dist[k][j]?dist[i][k]+dist[k][j]:dist[i][j],i\le k\le j$$

同时，我们还要设置一个二维数组next，来记录节点i到节点j路径上的i节点的下一个节点，例如路径为1–>2–>3–>4–>5，那么next[1][5]=2，next[2[5]=3，next[3][5]=4，next[4][5]=5，这样就可以把路径信息保存下来。

代码如下

// src表示源点，adjMatrix为保存图的邻接矩阵
void Graph::floyd(int src, std::vector<std::vector<int>>& dist, int adjMatrix[MAX][MAX])
{
   
    // 初始化一个二维向量 dist，用于存储所有节点之间的最短路径长度，初始值为无穷大(INF)
    dist = std::vector<std::vector<int>>(V, std::vector<int>(V, INF));
    // 将对角线上的元素设置为0，表示节点到自身的距离为0
    for (int i = 0; i < V; i++) {
   
        dist[i][i] = 0;
    }
    // 用于存储路径中下一个节点的信息
    std::vector<std::vector<int>> next(V, std::vector<int>(V, -1));
    for (int i = 0; i < V; i++)
        for (int j = 0; j < V; j++)
        {
   
            if (i != j && adjMatrix[i][j] != INF) {
   
                // 复制邻接矩阵的初始值到 dist 中
                dist[i][j] = adjMatrix[i][j];
                next[i][j] = j; // 如果有连接边，设置下一个节点为目标节点 j
            }
        }
           

    // 在三重循环中进行动态规划，遍历所有节点 k，更新从节点 i 到节点 j 的最短路径
    for (int k = 0; k < V; k++)
    {
   
        for (int i = 0; i < V; i++)
        {
   
            for (int j = 0; j < V; j++)
            {
   
                // 如果通过节点 k 能够获得更短的路径
                if (dist[i][k] + dist[k][j] < dist[i][j] && dist[i][k]!=INF && dist[k][j]!=INF)
                {
   
                    // 更新最短路径的值
                    dist[i][j] = dist[i][k] + dist[k][j];
                    // 更新路径中下一个节点的信息
                    next[i][j] = next[i][k]; 
                }
            }
        }
    }

那怎么把路径打印出来呢？也很简单，循环不断地求next[i][j]即可，代码如下

// src表示源点，dest表示目标节点
void Graph::saveFoPath(int src, int dest, std::vector<std::vector<int>>& next)
{
   
    std::vector<int> path;
    int current = src;
    while (current != dest) {
   
        path.push_back(current);
        current = next[current][dest];
    }
    path.push_back(dest);
    for (auto const& p : path)
    {
   
        std::cout<<p<<' ';
    }
    std::cout<<endl;
}