Floyd算法（一）

最新推荐文章于 2024-09-09 18:28:37 发布
最新推荐文章于 2024-09-09 18:28:37 发布
阅读量3.7k 收藏 6
点赞数
分类专栏： 智能算法 文章标签： Floyd算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41213648/article/details/82316357
版权

【1】为什么需要弗洛伊德算法？

带权图中单个源点到所有顶点的最短路径问题可以用《迪杰斯特拉算法》求解。

那如果要求图中每一个顶点与其它顶点之间的最短路径呢？类似可以想到的方法为：

每次以一个顶点为源点，重复执行地杰斯特拉算法算法n次。

这样，理论上我们便可以求得每一个顶点与其它顶点的最短路径，总的执行时间为O(n3）。

好吧！为了实现这个中需求，可以采用另外一种求解算法：弗洛伊德算法。

为了更好的理解弗洛伊德算法的精妙，我们先看简单的案例。

如下图是一个最简单的3个顶点连通网图：

 

【2】弗洛伊德算法

弗洛伊德算法是非常漂亮的算法，简洁直观大气上档次。

不过很可惜由于它的三重循环，因此也是O(n*n*n)的时间复杂度。

如果你面临需要求所有顶点至所有顶点的最短路径问题？

它是很好的选择。算法代码如下图：

 

关于本算法再不做详细赘述。如若感兴趣，下面的代码案例可以自己琢磨琢磨。

【3】弗洛伊德算法实现

注意：本算法的实现案例与迪杰斯特拉算法相同都是在求同一个图的最短路径问题。

不同的是这个算法可以求得所有顶点到所有顶点的最短路径。

模拟实现代码如下：

#include <iostream>
#include "SeqList.h"
#include <iomanip>
using namespace std;

#define  INFINITY  65535

typedef    int* pInt;
typedef pInt* ppInt;

template<class NameType, class DistType>
class Graph
{
private:
    SeqList<NameType> Vertices;
    DistType **Edges;
    int nVer, nEdges;

public:
    Graph() 
        : Edges(NULL)
        , nEdges(0)
        , nVer(0)
    {}
    ~Graph()
    {}

public:
    int GetVer() const
    {
        return nVer;
    }

    istream & operator>>(istream &in)
    {
        int v, u, value;
        int i, j;
        NameType item;
        cout << "请输入顶点的个数: " << endl;
        in >> nVer;
        cout << "请输入顶点的数据信息: " << endl;
        for (i = 0; i < nVer; ++i)
        {
            in >> item;
            Vertices.push_back(item);    // 保存全部顶点
        }
        /二维数组的创建并初始化
        Edges = new DistType*[nVer]; // DistType *ar[10];
        for (i = 0; i < nVer; ++i)
        {
            Edges[i] = new DistType[nVer];
            for (j = 0; j < nVer; ++j)
            {
                Edges[i][j] = 0;
            }
        }
        cout << "请输入边的个数: " << endl;
        in >> nEdges;
        cout << "请输入边的信息：" << endl;
        for (i = 0; i < nEdges; ++i)
        {
            in >> v >> u >> value;
            Edges[v][u] = value;
            Edges[u][v] = value;
        }
        return in;
    }
    ostream & operator<<(ostream &out) const
    {
        int i, j;
        out << "顶点信息 " << endl;
        for (i = 1; i <= nVer; ++i)
        {
            out << Vertices[i] << setw(5);
        }
        out << endl;
        out << "矩阵信息：" << endl;
        out << setw(10);
        for (i = 1; i <= nVer; ++i)
        {
            out << Vertices[i] << setw(5);
        }
        out << endl;
        for (i = 0; i < nVer; ++i)
        {
            out << Vertices[i+1] << setw(5);
            for (j = 0; j < nVer; ++j)
            {
                if (0 == Edges[i][j] && i != j)
                    Edges[i][j] = INFINITY;
                cout << Edges[i][j] << setw(5);
            }
            out << endl;
        }
        out << endl;

        return out;
    }
    // 弗洛伊德算法实现
    void ShortestPath_Floyd(int** p, int** D)
    {
        int v = 0, w = 0, k = 0;
        // 初始化数据
        for (v = 0; v < nVer; ++v)
        {
            for (w = 0; w < nVer; ++w)
            {
                D[v][w] = Edges[v][w];
                p[v][w] = w;
            }
        }
        for (k = 0; k < nVer; ++k)
        {
            for (v = 0; v < nVer; ++v)
            {
                for(w = 0; w < nVer; ++w)
                {
                    if (D[v][w] > D[v][k] + D[k][w])
                    {
                        D[v][w] = D[v][k] + D[k][w];
                        p[v][w] = p[v][k];
                    }
                }
            }
        }
    }
    // 打印矩阵信息
    void PrintArray(ppInt pp)
    {
        cout << setw(10);
        for (int i = 1; i <= nVer; ++i)
        {
            cout << Vertices[i] << setw(5);
        }
        cout << endl;
        for (int i = 0; i < nVer; ++i)
        {
            cout << Vertices[i+1] << setw(5);
            for (int j = 0; j < nVer; ++j)
            {
                cout << pp[i][j] << setw(5);
            }
            cout << endl;
        }
        cout << endl;
    }
    // 求解完成后打印所以路径信息
    void PrintPath(ppInt pp, ppInt DD)
    {
        int v, k, w;
        for (v = 0; v < nVer; ++v)
        {
            for (w = v+1; w < nVer; ++w)
            {
                cout << "V" << v << "-->" << "V" << w << " weight:" << DD[v][w] << endl;
                k = pp[v][w];
                cout << "Path:V" << v;
                while (k != w)
                {
                    cout << "-->V" << k;
                    k = pp[k][w];
                }
                cout << "-->V" << w << endl;
            }
        }
        cout << endl;
    }
};

template<class NameType, class DistType>
istream & operator>>(istream &in, Graph<NameType,DistType> &g)
{
    g >> in;
    return in;
}

template<class NameType, class DistType>
ostream & operator<<(ostream &out, const Graph<NameType,DistType> &g)
{
    g << out;
    return out;
}


void main()
{
    Graph<char, int> myg;
    cin >> myg;
    cout << "打印所有输入信息：" << endl;
    cout << myg << endl;
    cout << "求最短路径....." << endl;
    int numVer = myg.GetVer();
    ppInt pPathmatirx = new pInt[numVer];
    for (int i = 0; i < numVer; ++i)
    {
        pPathmatirx[i] = new int[numVer];
        for (int j = 0; j < numVer; ++j)
        {
            pPathmatirx[i][j] = 0;
        }
    }
    ppInt pShortPath = new pInt[numVer];
    for (int i = 0; i < numVer; ++i)
    {
        pShortPath[i] = new int[numVer];
        for (int j = 0; j < numVer; ++j)
        {
            pShortPath[i][j] = 0;
        }
    }
    myg.ShortestPath_Floyd(pPathmatirx, pShortPath);
    cout << "分别打印矩阵结果：" << endl;
    cout << "各顶点最短路径：" << endl;
    myg.PrintArray(pShortPath);
    cout << "各最短路径前驱顶点下标值：" << endl;
    myg.PrintArray(pPathmatirx);
    cout << "打印全部最短路径："<< endl;
    myg.PrintPath(pPathmatirx, pShortPath);
    // 释放二维数组
    for (int i = 0; i < numVer; ++i)      
        delete []pPathmatirx[i];   
    delete []pPathmatirx;
    for (int i = 0; i < numVer; ++i)      
        delete []pShortPath[i];   
    delete []pShortPath;
    pPathmatirx = NULL;
    pShortPath = NULL;
}
// 备注：
// 最短路径弗洛伊德算法实现
// 整理于2013-12-05
// 测试输入程序为：
/*
请输入顶点的个数:
9
请输入顶点的数据信息:
A B C D E F G H I
请输入边的个数:
16
请输入边的信息：
0 1 1
0 2 5
1 2 3
1 3 7
1 4 5
2 4 1
2 5 7
3 4 2
3 6 3
4 5 3
4 6 6
4 7 9
5 7 5
6 7 2
6 8 7
7 8 4
打印所有输入信息：
顶点信息
A    B    C    D    E    F    G    H    I
矩阵信息：
A    B    C    D    E    F    G    H    I
A    0    1    5655356553565535655356553565535
B    1    0    3    7    565535655356553565535
C    5    3    065535    1    7655356553565535
D65535    765535    0    265535    36553565535
E65535    5    1    2    0    3    6    965535
F6553565535    765535    3    065535    565535
G655356553565535    3    665535    0    2    7
H65535655356553565535    9    5    2    0    4
I655356553565535655356553565535    7    4    0


求最短路径.....
分别打印矩阵结果：
各顶点最短路径：
A    B    C    D    E    F    G    H    I
A    0    1    4    7    5    8   10   12   16
B    1    0    3    6    4    7    9   11   15
C    4    3    0    3    1    4    6    8   12
D    7    6    3    0    2    5    3    5    9
E    5    4    1    2    0    3    5    7   11
F    8    7    4    5    3    0    7    5    9
G   10    9    6    3    5    7    0    2    6
H   12   11    8    5    7    5    2    0    4
I   16   15   12    9   11    9    6    4    0

各最短路径前驱顶点下标值：
A    B    C    D    E    F    G    H    I
A    0    1    1    1    1    1    1    1    1
B    0    1    2    2    2    2    2    2    2
C    1    1    2    4    4    4    4    4    4
D    4    4    4    3    4    4    6    6    6
E    2    2    2    3    4    5    3    3    3
F    4    4    4    4    4    5    7    7    7
G    3    3    3    3    3    7    6    7    7
H    6    6    6    6    6    5    6    7    8
I    7    7    7    7    7    7    7    7    8

打印全部最短路径：
V0-->V1 weight:1
Path:V0-->V1
V0-->V2 weight:4
Path:V0-->V1-->V2
V0-->V3 weight:7
Path:V0-->V1-->V2-->V4-->V3
V0-->V4 weight:5
Path:V0-->V1-->V2-->V4
V0-->V5 weight:8
Path:V0-->V1-->V2-->V4-->V5
V0-->V6 weight:10
Path:V0-->V1-->V2-->V4-->V3-->V6
V0-->V7 weight:12
Path:V0-->V1-->V2-->V4-->V3-->V6-->V7
V0-->V8 weight:16
Path:V0-->V1-->V2-->V4-->V3-->V6-->V7-->V8
V1-->V2 weight:3
Path:V1-->V2
V1-->V3 weight:6
Path:V1-->V2-->V4-->V3
V1-->V4 weight:4
Path:V1-->V2-->V4
V1-->V5 weight:7
Path:V1-->V2-->V4-->V5
V1-->V6 weight:9
Path:V1-->V2-->V4-->V3-->V6
V1-->V7 weight:11
Path:V1-->V2-->V4-->V3-->V6-->V7
V1-->V8 weight:15
Path:V1-->V2-->V4-->V3-->V6-->V7-->V8
V2-->V3 weight:3
Path:V2-->V4-->V3
V2-->V4 weight:1
Path:V2-->V4
V2-->V5 weight:4
Path:V2-->V4-->V5
V2-->V6 weight:6
Path:V2-->V4-->V3-->V6
V2-->V7 weight:8
Path:V2-->V4-->V3-->V6-->V7
V2-->V8 weight:12
Path:V2-->V4-->V3-->V6-->V7-->V8
V3-->V4 weight:2
Path:V3-->V4
V3-->V5 weight:5
Path:V3-->V4-->V5
V3-->V6 weight:3
Path:V3-->V6
V3-->V7 weight:5
Path:V3-->V6-->V7
V3-->V8 weight:9
Path:V3-->V6-->V7-->V8
V4-->V5 weight:3
Path:V4-->V5
V4-->V6 weight:5
Path:V4-->V3-->V6
V4-->V7 weight:7
Path:V4-->V3-->V6-->V7
V4-->V8 weight:11
Path:V4-->V3-->V6-->V7-->V8
V5-->V6 weight:7
Path:V5-->V7-->V6
V5-->V7 weight:5
Path:V5-->V7
V5-->V8 weight:9
Path:V5-->V7-->V8
V6-->V7 weight:2
Path:V6-->V7
V6-->V8 weight:6
Path:V6-->V7-->V8
V7-->V8 weight:4
Path:V7-->V8
 */

 

                                            

扫码关注本人微信公众号，有惊喜奥！公众号每天定时发送精致文章！回复关键词可获得海量各类编程开发学习资料！

例如：想获得Python入门至精通学习资料，请回复关键词Python即可。

 

JiandaoStudio
关注
专栏目录
Flyod——最短路算法、求最小环
qq_43803508的博客
08-31 867
复杂度O(n3) 接触Floyd有一段时间了，但是对Floyd的印象就是，只记得它可以求任意两点间的最短距离，有三层循环，也不会用。。。。。 今天总结的时候看到挑战程序设计竞赛中的讲解 看到那个“三维数组”d，当时就懵了。。。。。 然后翻博客也只明白了，如果要让i、j两个点之间的距离变短，可以引入一个中转点k：i—>k—>j，或者多个中转点k1、k2：i—>k1—>k2—...
floyd算法
zhongkeli的专栏
04-22 4万+
这个算法主要要弄懂三个循环的顺序关系。 弗洛伊德（Floyd）算法过程： １、用D[v][w]记录每一对顶点的最短距离。 ２、依次扫描每一个点，并以其为基点再遍历所有每一对顶点D[][]的值，看看是否可用过该基点让这对顶点间的距离更小。 算法理解： 最短距离有三种情况： １、两点的直达距离最短。（如下图） ２、两点间只通过一个中间点而距离最短。（图） ３、两点间用通
Floyd算法
刺猬小屋
08-19 5599
 弗洛伊德（Floyd）算法过程：１、用D[v][w]记录每一对顶点的最短距离。２、依次扫描每一个点，并以其为基点再遍历所有每一对顶点D[][]的值，看看是否可用过该基点让这对顶点间的距离更小。算法理解：最短距离有三种情况：１、两点的直达距离最短。（如下图）２、两点间只通过一个中间点而距离最短。（图）３、两点间用通过两各以上的顶点而距离最短。（图）对于第一种情况：在初始化的时候就已经找出来了且
Floyd 算法
最新发布
George110915的博客
09-09 2041
核心代码只有三层循环，一行更新，十分简洁，可是这四行代码为什么就能求出任意两点的最短路径呢？f_{k - 1, i, k} + f_{k - 1, k, j} & 经过 k 节点 \。注：每次全排列后，通过最短路到达目前执行边起点，在起点加上本边边权。最短路径的子路径仍然是最短路径，这个定理显而易见，比如一条。但是，既然是动态规划，那么我们就要为问题做一个全新的定义。既然要经过所有边，我们就转化为要经过所有指定边的点。的最短路，反过来，如果说一条最短路必须要经过点。
Flyod 算法(两两之间的最短路径)
weixin_33912453的博客
07-26 308
Flyod 算法(两两之间的最短路径)动态规划方法，通过相邻矩阵， 然后把最后的结果存在这么一个矩阵里面，(i,j), #include &lt;iostream&gt; #include &lt;vector&gt; using namespace std; #define M 301 #define LIM 200000000 int w[M][M],d[2][M][M];   ...
Floyd - Warshall（弗洛伊德算法）
热门推荐
yuewenyao的博客
07-12 6万+
简介：Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 eg：暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费及方便计划旅程，小哼希望在出发前知道任意两个城市之...
python实现Floyd算法
01-20
下面是用Python实现Floyd算法的代码，供大家参考，具体内容如下 # -*- coding: utf-8 -*- Created on Thu Jul 13 14:56:37 2017 @author: linzr ## 表示无穷大 INF_val = 9999 class Floyd_Path(): def __...
Floyd算法_路径_floyd_matlab_
10-02
Floyd算法，也称为Floyd-Warshall算法，是图论中用于查找有向图或无向图中所有顶点之间最短路径的一种经典算法。该算法由Robert Floyd在1962年提出，适用于解决多源最短路径问题，即寻找从图中的一个节点到其他所有...
floyd_路径规划_Floyd算法_dynamicdijkstra_
09-30
"Floyd_路径规划_Floyd算法_dynamicdijkstra"这一主题主要涵盖了计算机科学中的路径规划问题，特别是Floyd算法的运用以及与Dijkstra算法的比较。本文将深入探讨Floyd算法的核心思想、实现过程、适用场景以及它与动态...
java实现Floyd算法
08-28
Floyd算法是一种用于解决多源最短路径问题的算法，它可以计算出所有节点之间的最短距离。该算法的思路是首先初始化距离矩阵，然后从第一个点开始逐渐更新矩阵点值。d[i][j]表示从i点到j点的距离。第k次更新时，判断d...
Floyd算法详讲
飘过的小牛
09-13 1万+
正如我们所知道的，Floyd算法用于求最短路径。Floyd算法可以说是Warshall算法的扩展，三个for循环就可以解决问题，所以它的时间复杂度为O(n^3)。 Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) +
弗洛伊德（Floyd）算法过程
FTK's Blog
07-23 1万+
 弗洛伊德（Floyd）算法过程：１、用D[v][w]记录每一对顶点的最短距离。２、依次扫描每一个点，并以其为基点再遍历所有每一对顶点D[][]的值，看看是否可用过该基点让这对顶点间的距离更小。算法理解：最短距离有三种情况：１、两点的直达距离最短。（如下图）２、两点间只通过一个中间点而距离最短。（图）３、两点间用通过两各以上的顶点而距离最短。（图）对于第一种情况：在初始化的时候就已经找出来了且以后
Flyod算法
weixin_43404836的博客
07-29 693
Flyod算法一、Floyd算法介绍？二、matlab实现1. 主程序：2. 函数三、扩展1、完备性证明2、特殊情况四、参考阅读 一、Floyd算法介绍？ Floyd‐Warshall算法（英语：Floyd‐Warshall algorithm或简写为Floyd algorithm），中文亦称弗洛伊德算法，是解决任意两点间的最短路径的一种算法，可以正确处理无向图或有向图（可以有负权重，但不可存在负权回路）的最短路径问题。 Floyd算法与迪杰斯特拉算法或贝尔曼福特算法相比，能够一次性的求出任意两点之间的最
Floyd算法简介
weixin_33916256的博客
03-07 130
参考：https://blog.csdn.net/qq_35644234/article/details/60875818 一.Floyd算法的介绍 1.算法的特点： 弗洛伊德算法是解决任意两点间的最短路径的一种算法，可以正确处理无向图或有向图或负权（仅适合权值非负的图)的最短路径问题，同时也被用于计算有向图的传递闭包。 2.算法的思路：　　通过Floyd计算图G=(V,E)中...
算法：Floyd-Warshall
小猪快跑
01-22 955
算法：Floyd-Warshall
UVA 10048 Flyod算法
zhenlingcn的博客
03-24 328
题意给C个点，S条边，Q次查询。每次查询查询两个点之间边最大值最小的路径。求这个路径的边最大值。题解Flyod简单变形，d[i][j]=min(d[i][j],max(d[i][k],d[k][j]))即可注意事项输出好坑，非常容易PE。注意空行和空行输出位置！！！代码#include <iostream> #include<cstdio> #include<algorithm> #define I
Floyd算法优化仓库选址问题C++实现
Floyd算法与选址问题的结合是运筹学和计算机科学交叉领域中的一个重要应用。Floyd算法，也称为Floyd-Warshall算法，是一种用于寻找给定加权图中所有顶点对之间最短路径的动态规划算法。而选址问题（Facility ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值