最短路径 -- Floyd-Warshall & Dijkstra & spfa 学习和思考

最新推荐文章于 2024-07-14 19:56:17 发布
最新推荐文章于 2024-07-14 19:56:17 发布
阅读量415 收藏
点赞数
分类专栏： 算法 文章标签： 算法 谷歌
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/milesfei_AC/article/details/48783145
版权

Floyd-Warshall & Dijkstra & spfa

最近在强化自己的图论算法，首先翻看以前的图论题目（此题需翻墙）
Google APAC 2016 University Graduates Test Round A：Problem C. gCampus

此题应用最短路径的Floyd-Warshall算法可以轻松解决，可惜当时没能熟练掌握，大数据挂了。

于是恶补之，参考：
http://blog.chinaunix.net/uid-26548237-id-3834873.html

  • Floyd-Warshall算法应用了最短路径的哪些性质？

A到B 的最短路如果经过 C，那么其路径一定是 A到C 和 C到B 的最短路相连接形成的。

所以在记录路径的时候（那个记录路径的矩阵），记录的是 u到v 的最短路径所经过的第一个顶点，比如记为 k1，那么寻找路径的时候，第一步可以找到 k1，然后继续寻找 k1到v 的最短路径即可。

  • Dijkstra算法

与最小生成树方法的过程相同，只是 松弛 的记录方法和代表的意义略有区别。最小生成树记录的是每个点到最小生成树的距离，最短路记录的是每个节点到源点的最短路径的距离。

  • spfa算法

这是改进的 Bellman-Ford 算法，通过优先队列控制松弛次数，使得循环可以提前退出。也是单源最短路的经典算法！

附上通过代码（Floyd-Warshall）：

#include <stdio.h>

#define INT_MAX 1e14

#define min(a,b) (((a) < (b)) ? (a) : (b))

int T, ti, i, j, k, x, y, d;
int N, M;
long long mpi[10001][3], dst[101][101];
//mpi 记录每条边的起点，终点，权重
//dst 记录距离矩阵

void init() {
    /*
    初始化距离矩阵
    */
    for (i = 0; i < 101; i++) {
        for (j = 0; j < 101; j++) {
            dst[i][j] = INT_MAX;
        }
    }

    for (i = 0; i < 101; i++) {
        dst[i][i] = 0;
    }
}

int main() {
    scanf("%d", &T);
    for (ti = 1; ti <= T; ti++) {
        init();
        scanf("%d %d", &N, &M);
        for (i = 0; i < M; i++) {
            scanf("%d %d %d", &x, &y, &d);
            mpi[i][0] = x;
            mpi[i][1] = y;
            mpi[i][2] = d;
            dst[x][y] = min(dst[x][y], d);
            dst[y][x] = min(dst[y][x], d);
            //输入注意处理：重复输入！
        }

        //计算距离矩阵，应用Floyd算法
        for (k = 0; k < N; k++) {
            for (i = 0; i < N; i++) {
                for (j = 0; j < N; j++) {
                    if (dst[i][k] != INT_MAX && dst[k][j] != INT_MAX &&
                    dst[i][k] + dst[k][j] < dst[i][j]) {
                        dst[i][j] = dst[i][k] + dst[k][j];
                    }
                }
            }
        }

        printf("Case #%d:\n", ti);
        int ok;
        for (k = 0; k < M; k++) {
            x = mpi[k][0];
            y = mpi[k][1];
            ok = 1;
            //寻找无效边，构造输出
            for (i = 0; i < N && ok; i++) {
                for (j = 0; j < N && ok; j++) {
                    if (dst[i][j] == dst[i][x] + mpi[k][2] + dst[y][j]) {
                        ok = 0;
                    }
                }
            }
            if (ok) {
                printf("%d\n", k);
            }
        }

    }
    return 0;
}

附上通过代码（Dijkstra）：

#include <stdio.h>
#include <string.h>

#define INT_MAX 1e14

#define min(a,b) (((a) < (b)) ? (a) : (b))

int T, ti, i, j, k, x, y, d;
int N, M;
long long mpi[10001][3], dst[101][101], rt[101][101], vis[101];
//mpi 记录每条边的起点，终点，权重
//dst 记录距离矩阵
//rt  记录单源最短路中每个源点到终点的距离
//vis 标记节点访问情况

void init() {
    /*
    初始化距离矩阵
    */
    for (i = 0; i < 101; i++) {
        for (j = 0; j < 101; j++) {
            dst[i][j] = INT_MAX;
        }
    }

    for (i = 0; i < 101; i++) {
        dst[i][i] = 0;
    }
}

int main() {
    scanf("%d", &T);
    for (ti = 1; ti <= T; ti++) {
        init();
        scanf("%d %d", &N, &M);
        for (i = 0; i < M; i++) {
            scanf("%d %d %d", &x, &y, &d);
            mpi[i][0] = x;
            mpi[i][1] = y;
            mpi[i][2] = d;
            dst[x][y] = min(dst[x][y], d);
            dst[y][x] = min(dst[y][x], d);
            //输入注意处理：重复输入！
        }

        //计算每个点的单源最短路的距离，应用Dijstra算法
        int pre, imin;
        long long nmin;
        for (k = 0; k < N; k++) {
            for (i = 0; i < N; i++) rt[k][i] = INT_MAX;
            rt[k][k] = 0;
            memset(vis, 0, sizeof(vis));
            vis[k] = 1;
            //求以k为源点的单源最短路
            pre = k;
            for (i = 1; i < N; i++) {
                for (j = 0; j < N; j++) {
                    if (vis[j] == 1) continue;
                    if (rt[k][pre] + dst[pre][j] < rt[k][j]) {
                        rt[k][j] = rt[k][pre] + dst[pre][j];
                    }
                }
                nmin = INT_MAX;
                imin = -1;
                for (j = 0; j < N; j++) {
                    if (vis[j] == 0 && rt[k][j] < nmin) {
                        nmin = rt[k][j];
                        imin = j;
                    }
                }

                vis[imin] = 1;
                pre = imin;
            }
        }

        printf("Case #%d:\n", ti);
        int ok;
        for (k = 0; k < M; k++) {
            x = mpi[k][0];
            y = mpi[k][1];
            ok = 1;
            //寻找无效边，构造输出
            for (i = 0; i < N && ok; i++) {
                for (j = 0; j < N && ok; j++) {
                    if (rt[i][j] == rt[i][x] + mpi[k][2] + rt[y][j]) {
                        ok = 0;
                    }
                }
            }
            if (ok) {
                printf("%d\n", k);
            }
        }
    }

    return 0;
}

附上通过代码（spfa）：

#include <stdio.h>
#include <string.h>
#include <queue>

#define min(a,b) (((a) < (b)) ? (a) : (b))
#define MAX 0x7F

using namespace std;

int T, Ti, N, M, x, y, d, i, j, k;
long long pt[10001][3], mp[101][101], dis[101][101];
int vis[101];

int main() {
    scanf("%d", &T);
    for (Ti = 1; Ti <= T; Ti++) {
        scanf("%d %d", &N, &M);

        //map input
        memset(mp, MAX, sizeof(mp));
        for (i = 0; i < M; i++) {
            scanf("%d %d %d", &x, &y, &d);
            mp[x][y] = min(mp[x][y], d);
            mp[y][x] = min(mp[y][x], d);
            pt[i][0] = x;
            pt[i][1] = y;
            pt[i][2] = d;
        }

        //spfa
        memset(dis, MAX, sizeof(dis));
        for (k = 0; k < N; k++) {
            queue<int> que;
            que.push(k);
            memset(vis, 0, sizeof(vis));
            vis[k] = 1;
            dis[k][k] = 0;
            while (!que.empty()) {
                int tp = que.front();
                que.pop();
                for (i = 0; i < N; i++) {
                    if (mp[tp][i] == MAX) continue;
                    if (dis[k][i] > dis[k][tp] + mp[tp][i]) {
                        dis[k][i] = dis[k][tp] + mp[tp][i];
                        if (vis[i] == 0) {
                            vis[i] = 1;
                            que.push(i);
                        }
                    }
                }
                vis[tp] = 0;
            }
        }

        //find inefficient road
        printf("Case #%d:\n", Ti);
        int ok;
        for (k = 0; k < M; k++) {
            x = pt[k][0];
            y = pt[k][1];
            d = pt[k][2];
            ok = 1;
            for (i = 0; i < N && ok; i++) {
                for (j = 0; j < N && ok; j++) {
                    if (dis[i][j] == dis[i][x] + d + dis[y][j]) {
                        ok = 0;
                    }
                }
            }

            if (ok) {
                printf("%d\n", k);
            }
        }
    }
    return 0;
}
milesfei_AC
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法系列：最短路径问题详解——Dijkstra算法、Floyd-Warshall算法、Bellman-Ford算法（SPFA算法）
闵行小鱼塘
09-15 1096
本篇归纳最短路径问题，从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径，主要有三种算法：Dijkstra算法、Floyd-Warshall算法、Bellman-Ford算法（SPFA算法）
最短路的Floyd-Dijkstra-Spfa板子
02-06
做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..
最短路径算法——Dijkstra,Bellman-Ford,Floyd-Warshall,Johnson
dianzhixie7235的博客
08-17 232
根据DSqiu的blog整理出来 ：http://dsqiu.iteye.com/blog/1689163 PS：模板是自己写的，如有错误欢迎指出~ 本文内容框架： §1 Dijkstra算法 §2 Bellman-Ford算法 §3 Floyd-Warshall算法 §4 Johnson算算法 §5 问题归约 §0 小结 常用的最短路径算法有：Dijkst...
Floyd-Warshall、Dijkstra、Bellman–Ford、SPFA
阿呆的专栏
02-15 464
最短路径算法 Floyd-Warshall（弗洛伊德算法） 弗洛伊德算法的原理是动态规划，用于计算两点之间的最短路径。该算法的优点在于极其简单，代码仅几行。缺点是时间复杂度高O(n3)，空间复杂度Ω(n2) 算法描述 算法用于比较图结构中两个顶点间所有可能的路径。点集合设为V(1…k)，求点i，点j中间经过k的最短距离D(i,j,k) 最短路径经过点k。D(i,j,k)=D(i,k,k-1)+D...
最短路算法——Floyd-Warshall
指北针_N的博客
04-15 5929
在更多的应用场景中，需要用不同的算法来解决。下表总结了一些经典算法，除了贪心最优搜索之外，其他都是最优性算法，即得到的解是最短路径。表中的 m 是边的数量，n 是点的数量。 一、BFS BFS 也是一种很不错的最短路算法。但 BFS 只适合一种场景：任意的相邻两点之间距离相等，一般把这个距离看成 1，称为“1跳”，从起点到终点的路径长度就是多少个“跳数”。在这种场景下，查找一个起点到一个终点的最有短距离，BFS 是最优的最短路径算法，计算复杂度是 O(n)，n 是图上点的...
数据结构-图详解（最短路径问题-Dijkstra，Bellman-Ford，Floyd-Warshall算法 -C++）
dodamce的博客
07-23 2430
源节点到结点P的代价(代价为0)与P点到adjoinPoint的代价和（5+0和10+0）与源节点到adjoinPoint代价（无穷（默认值））相比要小，根据上面的过程分析，需要将源节点到adjoinPoint的代价更新为源节点到P与P到adjoinPoint的代价之和。第三次，先从Q组找一个起点到源节点路径最小的节点P，P点就是图中的z点。P点相邻的节点有x，s点，源节点到x点距离根据上图可知为14，源节点到P与P到x代价和为7+6=13，两者相比把小的更新到源节点到x代价即可。......
图论--最短路径问题--Dijkstra算法和Floyd算法
Sunflower的博客
08-14 7839
最短路径之       (一)简单了解： 用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。 最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短 路径。 算法具体的形式包括： 确定起点的最短
最短路径之Dijkstra算法和Floyd-Warshall算法
zhangjunqis的博客
08-14 782
最短路径算法 最短路径算法通常用在寻找图中任意两个结点之间的最短路径或者是求全局最短路径，像是包括Dijkstra、A*、Bellman-Ford、SPFA(Bellman-Ford的改进版本)、Floyd-Warshall、Johnson、BFS等等，这里要集中介绍Dijkstra和Floyd，前者用来处理任意两个结点之间的最短路径，后者处理图中所有的最短路径。 Dijkstra
几大最短路径算法比较（Floyd & Dijkstra & Bellman-Ford & SPFA）
AI蜗牛之家
04-25 2792
几个最短路径算法的比较： Floyd        求多源、无负权边（此处错误？应该可以有负权边）的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。        Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题。 Floyd-Warshall算法的时间复杂度为
最短路径--Floyd、Dijkstra、Bellman、SPFA算法
weixin_34009794的博客
08-22 81
前言 　　最短路径是数据结构-图中的一个经典问题，求解最短路径的问题，有四种算法，这四种算法各有各的不同，分别是： 　　Floyd算法、Dijkstra算法、Bellman算法以及SPFA算法。 　　最常用的是前两者，当然你也可以都掌握，毕竟各有各的好处。 1.Floyd-Warshall算法 　　优点：实现代码极其简便，比较好理解。 　　缺点：时间复杂度较高，为O（n3），适用于数据...
三种算法（Floyd、Dijkstra、SPFA）求单源点最短路径。
04-13
本文将详细探讨三种经典的单源点最短路径算法：Floyd-Warshall算法、Dijkstra算法和SPFA（Shortest Path Faster Algorithm）。这些算法在处理不同的图结构和需求时各有优势。 首先，Floyd-Warshall算法是一种动态...
the-short-way.zip_short_最短路径 贪心算法
09-14
Dijkstra算法和Floyd-Warshall算法是解决单源最短路径问题的经典算法，它们并不属于贪心算法。 对于多点最短路径，一种可能的贪心策略是每次选择未访问且与当前路径代价最小的节点，但这通常无法保证得到全局最优解...
最短路径_路径_matlab求最短路径_复杂网络_
09-29
在Matlab中，我们可以使用Dijkstra算法、Floyd-Warshall算法或者Bellman-Ford算法来寻找复杂网络中的最短路径。这些算法各有优缺点，例如Dijkstra适用于有向无权或有权图，而Floyd-Warshall可以处理负权重，但不能...
最短路全家桶（Floyd,Dijkstra,SPFA）
06-02
本文将深入探讨三个著名的最短路径算法：Floyd算法、Dijkstra算法和SPFA（Shortest Path Faster Algorithm）。这些算法广泛应用于图论和网络分析，特别是在路由选择、物流规划、社交网络分析等场景。 1. **Floyd...
36. Adam 算法详解
qq_41238579的博客
07-10 947
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1531
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 281
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 114
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
【排序 - 堆排序】
2302_80393814的博客
07-10 490
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值