图论最短路之Floyd、Dijkstra、Bellman-Ford、Spfa（详细分析）

最新推荐文章于 2021-12-11 15:53:55 发布
最新推荐文章于 2021-12-11 15:53:55 发布
阅读量463 收藏 3
点赞数 2
分类专栏： 最短路 图论 文章标签： 图论 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqbz_lanziming/article/details/107886631
版权
本文详细介绍了四种最短路径算法：Floyd、Dijkstra、Bellman-Ford和SPFA，包括它们的算法描述、代码实现以及适用情况。Floyd适合负边权，Dijkstra适用于正权图，Bellman-Ford能处理负权图，而SPFA是对Bellman-Ford的优化，适用于稀疏图。
摘要由CSDN通过智能技术生成

这一篇博客主要是最短路四大方法模板的归纳

一、Floyd

佛洛伊德是最简单的最短路径算法，可以计算图中任意两点间的最短路径。时间复杂度为O(N3)，适用于出现负边权的情况。
算法描述：
( a )初始化：点u、v如果有边相连，则dis[u][v]=w[u][v]
如果不相连，则dis[u][v]=0x3f
( b )模板:

for(k=1;k<=n;k++){
	for(i=1;i<=n;i++){
		for(j=1;j<=n;j++){
			if(dis[i][j]>dis[i][k]+dis[k][j])
			  	dis[i][j]=dis[i][k]+dis[k][j];
		}
	}
}

( c )算法结束：dis[i][j]得出的就是任意起点i到任意终点j的最短路径。

完整代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int M=1005;
int dis[M][M];
int main(){
	int n,m;
	scanf("%d %d",&n,&m);//n代表点数，m代表边数
	for(int i=1;i<=m;i++){
		int s,t,w;
		scanf("%d %d %d",&s,&t,&w);
		dis[s][t]=w;
	//  dis[t][s]=w;如是无向图则加上这一行
	}
	int S,T;
	scanf("%d %d",&S,&T);
	for(int k=1;k<=n;k++){
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(dis[i][j]>dis[i][k]+dis[k][j])
			  		dis[i][j]=dis[i][k]+dis[k][j];
			}
		}
	}
	printf("%d",dis[S][T]);
}

二、Dijkstra

结点分成两组：已经确定最短路、尚未确定最短路不断从第2组中选择路径长度最短的点放入第1组并扩展本质是贪心，只能应用于正权图

算法描述：
设起点为s，dis[v]表示从指定起点s到v的最短路径，pre[v]为v的前驱，用来输出路径
(a)初始化

	memset(dis,+∞)，memset(vis,0)；
    (v:1~n)dis[v]=w[s][v],bool vis[v]=0；
    dis[s]=0；pre[s]=0；vis[s]=1；

(b)

for(i=1;i<=n-1;i++)
        1 在没有被访问过的点中找一个相邻顶点k，使得dis[k]是最小的；
        2 k标记为已确定的最短路vis[k]=true;
        3 用for循环更新与k相连的每个未确定最短路径的顶点v (所有未确定最短路的点都松弛更新)
      	if(dis[k]+w[k][v]<dis[v]) dis[v]=dis[k]+w[k][v],pre[v]=k;

（c）算法结束dis[v]为s到v的最短路距离；pre[v]为v的前驱结点，用来输出路径。



Dijkstra 分为三种类型:
Dijkstra 分为三种类型
普通
邻接表
堆优化

① 普通代码

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int M=2005;
int G[M][M];
int dis[M];
bool flag[M];
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<=n;i++){
		for(int j=0;j<=n;j++){
			G[i][j]=0x3f3f3f3f;
		}
		dis[i]=0x3f3f3f3f;
		G[i][i]=0;
	}//赋初值，最好不要使用memset
	for(int i=1;i<=m;i++){
		int s,t,w;
		scanf("%d %d %d",&s,&t,&w);
		G[s][t]=min(G[s][t],w);
	  //G[t][s]=min(G[t][s],w);如果是双向加
	}
	int S,T;
	scanf("%d %d",&S,&T);
	dis[S]=0,flag[S]=true;
	for(int i=1;i<=n;i++){
		int id=0;
		for(int j=1;j<=n;j++){
			if((!flag[j])&&(id==0||dis[id]>dis[j])){
				id=j;
			}
		}
		flag[id]=true;
		for(int j=1;j<=n;j++){
			dis[j]=min(dis[j],dis[id]+G[id][j]);
		}
	}
	printf("%d",dis[T]);
}

② 邻接表代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
const int M=1005;
int n,m;
int dis[M];
bool flag[M];
struct edge{
	int v,w;
	edge(){}
	edge(int V,int W){
		v=V,w=W;
	}
};
vector<edge> G[M];
int Dijkstra(int S,int T){
	memset(dis,0x3f,sizeof(dis)); 
	dis[S]=0;
	for(int i=1;i<=n;i++){
		int id=0;
		for(int j=1;j<=n;j++){
			if(dis[j]<dis[id]&&flag[j]==false){
				id=j;
			}
		}
		flag[id]=true;
		int siz=G[id].size();
		for(int j=0;j<siz;j++){
			int v=G[id][j].v,w=G[id][j].w;
			dis[v]=min(dis[v],dis[id]+w);
		}
	}
	return dis[T];
}
void Edge(int s,int t,int w){
	G[s].push_back(edge(t,w));
//	G[t].push_back(edge(s,w));如是无向加
}
int main(){
	scanf("%d %d",&n,&m);
	for(int i=1;i<=m;i++){
		int s,t,w;
		scanf("%d %d %d",&s,&t,&w);
		Edge(s,t,w);
	}
	int S,T;
	scanf("%d %d",&S,&T);
	printf("%d",Dijkstra(S,T));
}

③ 堆优化代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue> 
using namespace std; 
const int M=100005;
int dis[M];
bool flag[M];
struct edge{
	int v,w;
	edge(){
	}
	edge(int V,int W){
		v=V,w=W;
	}
};
struct node{
	int u,dis;
	node(){
	}
	node(int U,int D){
		u=U,dis=D;
	}
	friend bool operator < (node a,node b){return a.dis>b.dis;}
};
vector<edge> G[M];
priority_queue<node> Q;
int Dijkstra(int S,int T){
	memset(dis,0x3f,sizeof(dis));
	dis[S]=0,Q.push(node(S,0));
	while(!Q.empty()){
		int u=Q.top().u;
		Q.pop();
		if(flag[u]) continue;
		flag[u]=true;
		int v,w,siz=G[u].size();
		for(int i=0;i<siz;i++){
			v=G[u][i].v,w=G[u][i].w;
			if(dis[v]>dis[u]+w){
				dis[v]=dis[u]+w;
				Q.push(node(v,dis[v]));
			}
		}
	}
	return dis[T];
}
void Edge(int x,int y,int z){
	G[x].push_back(edge(y,z));
}
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	for(int i=1;i<=m;i++){
		int s,t,w;
		scanf("%d %d %d",&s,&t,&w);
		Edge(s,t,w);
	}
	int S,T;
	scanf("%d %d",&S,&T);
	printf("%d",Dijkstra(S,T));
}

三、Bellman-Ford

对每条边执行更新，迭代N-1次，可以应用于负权图。
（1）初始化：dis[s] = 0, dis[i] = 0x3f3f3f3f(i≠s), pre[s]=0。
（2）

for (i = 1; i <= nodenum – 1; i ++)
       for (j = 1; j <= edgenum – 1; j ++)
               if (dis[u] + w[j] < dis[v]) {         //relax
                       dis[v] = dis[u] + w[j];
                       pre[v] = u;
               }

完整代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
const int M=100005;
int dis[M];
int S,T,n,m;
struct node{
	int ui,vi,wi;
}edge[M];
bool BellmanFord(){
	memset(dis,0x3f,sizeof(dis));
	for(int i=1;i<=n-1;i++){
		for(int j=1;j<=m;j++){
			if(dis[edge[j].vi]>dis[edge[j].ui]+edge[j].wi){
				dis[edge[j].vi]=dis[edge[j].ui]+edge[j].wi;
			}
		}
	}
	bool flag=true;
	for(int i=1;i<=m;i++){
		if(dis[edge[i].vi]>dis[edge[i].ui]+edge[i].wi){
			flag=false;
			break;
		}
	}
	if(flag==true){
		return true;
	}
	return false;
}
int main(){
	
	scanf("%d %d",&n,&m);
	for(int i=1;i<=m;i++){
		scanf("%d %d %d",&edge[i].ui,&edge[i].vi,&edge[i].wi);
	}
	int S,T;
	scanf("%d %d",&S,&T);
	for(int i=1;i<=m;i++){
		if(edge[i].ui==S){
			dis[edge[i].vi]=edge[i].wi;
		}
	} 
	dis[S]=0;
	if(BellmanFord()){
		printf("%d",dis[T]);
		return 0;
	}
	return 0;
}

四、Spfa

SPFA = 队列优化的Bellman-Ford算法，本质上还是迭代——每更新一次就考虑入队稀疏图上O(kN)，稠密图上退化到O(N^2)，可以应用于负权图

算法实现：
在Bellmanford算法中，有许多松弛是无效的。这给了我们很大的改进的空间。SPFA算法正是对Bellmanford算法的改进。它是由西南交通大学段丁凡1994提出的。它采用了队列和松弛技术。先将源点加入队列。然后从队列中取出一个点(此时该点为源点)，对该点的邻接点进行松弛，如果该邻接点松弛成功且不在队列中，则把该点加入队列。如此循环往复，直到队列为空，则求出了最短路径。
判断有无负环：如果某个点进入队列的次数超过N次则存在负环 ( 存在负环则无最短路径,如果有负环则会无限松弛,而一个带n个点的图至多松弛n-1次)

完整代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int M=100005;
int dis[M];
bool flag[M];
int S,T,n,m;
struct node{
	int si,ti,wi;
	node(){}
	node(int X,int Y){
		ti=X,wi=Y;
	}
};
queue<int> q;
vector<node> vec[M];
void Edge(int x,int y,int z){
	vec[x].push_back(node(y,z));
//	vec[y].push_back(node(x,z));如是无向图加
}
int SPFA(){
	memset(dis,0x3f,sizeof(dis));
	memset(flag,false,sizeof(flag));
	dis[S]=0,flag[S]=true,q.push(S);
	while(!q.empty()){
		int x=q.front();
		q.pop();
		flag[x]=false;
		int siz=vec[x].size();
		for(int i=0;i<siz;i++){
			int Ti=vec[x][i].ti,Wi=vec[x][i].wi;
			if(dis[Ti]>dis[x]+Wi){
				dis[Ti]=dis[x]+Wi;
				if(!flag[x]){
					q.push(Ti),flag[Ti]=true;
				}
			}
		}
	}
	return dis[T];
}
int main(){
	memset(dis,0x3f,sizeof(dis));
	scanf("%d %d",&n,&m);
	for(int i=1;i<=m;i++){
		int s,t,w;
		scanf("%d %d %d",&s,&t,&w);
		Edge(s,t,w);
	}
	int S,T;
	scanf("%d %d",&S,&T);
	int id1=SPFA();
	printf("%d",id1);
}

总结

这次csp做的非常不好，其主要原因是在于思维没有打开，还有在考场上的策略有错误，而导致时间的不够以及题的思考深度不够。
但是这次也深刻的提醒与我，在平时的训练中更需要自己的思维训练。

所有代码纯手打，点个赞再走呗！

cqbz_lanziming
关注
专栏目录
图论基础就是一些NOI学习中比较简单的图论基础，如存图，读图，dijkstra，SPFA，Bellman-Ford，Floyd等
07-06
### 图论基础知识详解 #### 一、图的基本概念 ...接下来，我们还可以继续深入学习图的其他存储方式，如邻接表等，以及更高级的图算法，如Dijkstra算法、SPFA算法、Bellman-Ford算法和Floyd算法等。
计算时间复杂度详解
最新发布
qq_52905520的博客
05-05 3672
计算时间复杂度详解
dijkstra算法 bellman-ford算法 SPFA算法 floyd算法 (图论，最短路)
qq_54185946的博客
10-01 427
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 最短路问题 最短路问题可以分为两大类，单源最短路，和多源汇最短路问题。 源点就是起点的意思。 单源最短路又分为存在负权边和不存在负权边的两种情况。 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、(朴素)Dijkstra算法 示例：pandas 是基于NumPy 的
最短路的三种算法（Floyd、Dijkstra、SPFA）
热门推荐
小女不才
12-14 2万+
前言乍一看搜索跟这个一样都可以找出一个点到另一个点的最短距离，但是有些问题两者都可以解决，而另一些搜索就不能解决了，搜索有确定的方向一步一步走，而最短路是告诉你某两个点直接可以直接走，没有确定的方向。最短路问题，通俗的说就是就是给你n个点，m条边，然后找出某两个点之间的最短距离。解决最短路常用的有三种算法Floyd、Dijkstra、SPFA。三种方法各有优劣 Floyd算法是多源最短路算法，复杂度
floyed算法、dijkstra算法、SPFA算法
l870358133的博客
07-28 736
转自gzr的博客：https://www.cnblogs.com/TFLS-gzr/p/10381849.html，https://www.cnblogs.com/TFLS-gzr/p/10387463.html 感觉这是我目前浏览找到的最短路问题讲解中比较通俗易懂的，转载只为方便自己在遗忘的时候可以及时查阅，不必再去找，感谢作者gzr！ 1 floyed算法 1）明确思想及功效：在图中求最...
图论算法之最短路径（Dijkstra、Floyd、Bellman-ford和SPFA）
HX_2021
11-18 1万+
图论算法之最短路径（Dijkstra、Floyd、Bellman-ford和SPFA） 1、图论最短路径概述 图论算法为了求解一个顶点到另一个顶点的最短路径，即如果从图中某一顶点（称为源点）到达另一顶点（称为终点）的路径可能不止一条，如何找到一条路径，使得沿此路径各边上的权值总和（即从源点到终点的距离）达到最小，这条路径称为最短路径（shortestpath）。 最短路径有很多特殊的情况，包括有向图还是无向图，有没有负权边等。通常解决图论中最短路径问题的算法有Dijkstra、Floyd、Bellman-f
最短路全家桶（Floyd,Dijkstra,SPFA）
06-02
相比于Bellman-Ford算法，SPFA在实践中通常更快，但其最坏情况下的时间复杂度仍为O(n^2)。SPFA对于稀疏图，即边的数量远小于节点数量的情况，表现良好。 链式前向星存图是一种常用的图存储结构，它使用邻接表而非...
三种算法（Floyd、Dijkstra、SPFA）求单源点最短路径。
04-13
最后，SPFA（Shortest Path Faster Algorithm）是对Bellman-Ford算法的一种优化，适用于稀疏图。与Dijkstra算法不同，SPFA使用队列来处理节点，但允许在队列中有多个相同节点，以防止负权环导致无限循环。尽管SPFA在...
Shortest-path-template.rar_SPFA
09-23
本压缩包文件“Shortest-path-template.rar_SPFA”提供了四种经典的最短路径算法模板：Dijkstra算法、Bellman-Ford算法、SPFA（Shortest Path Faster Algorithm）以及Floyd-Warshall算法。这些算法主要适用于加权有...
最短路的Floyd-Dijkstra-Spfa板子
02-06
做ACM最短路问题普遍算法的Floyd-Dijkstra-Spfa板子..
最短路径问题（Floyd算法、Dijkstra算法、Bellman-Ford算法、SPFA算法）
yuhaomogui的博客
12-11 4415
导入 最短路径问题是指在一幅带权图中，找出连接两个顶点之间的所有路径中，边权和最短的那一条。如下图就是一幅带权图，边上的数字就代表该边的权值。解决最短路径问题有多种不同的算法，本文将对它们的基本思想与优化操作一一进行介绍。.........
几个最短路径算法Floyd、Dijkstra、Bellman-Ford、SPFA的比较
dinongxu8804的博客
02-12 1207
几大最短路径算法比较 July、二零一一年二月十二日。----------------------------------- 几个最短路径算法的比较：Floyd 求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任...
最短路径算法对比比较（bellman-ford，dijkstra，spfa，floyd比较）
yuewenyao的博客
07-12 1万+
floyd （弗洛伊德算法） Dijkstra（迪杰斯特拉算法） bellman-ford（贝尔曼夫德算法） spfa 空间复杂度 O（N²） O（M） O（M） O（M） 时间复杂度 O（N³） O（（m+n）logN） O（MN） 最坏也是O（NM） 适用情况 稠密图和顶点关系密切 ...
最短路算法：Dijkstra算法、Bellman-Ford算法、spfa算法和Floyd算法
qq_40586164的博客
06-19 1429
最短路算法的分类： 单源最短路 所有边权都是正数 朴素的Dijkstra算法 O(n^2) 适合稠密图（n为节点个数） 堆优化版的Dijkstra算法 O((m+n)log n)（m是图中边的个数）适合稀疏图 存在负权边 Bellman-Ford O(nm) spfa 一般O(m),最坏O(nm) 多源汇最短路 Floyd算法 O(n^3) 【例题】 【方法一】朴素Dijkstra class Solution { publ
最短路问题的四种算法（Bellman-ford、SPFA、Dijkstra、Floyd）
烤上地瓜
03-04 559
Bellman-Ford算法 Bellman-Ford算法用来计算单源最短路。该算法可以处理边权为负的情况，同时可以判断图中是否有负权环。 松弛一条边(u,v)即判断能否通过u对v的最短路径进行改进，如果可以，则更新d[v]。 松弛操作：d[v]>d[u]+w(u,v) → d[v]=d[u]+w(u,v) 。其中w(u,v)表示边(u,v)的权值。 松弛操作在没有负权环的情况下最多进行|V...
最短路算法详解（Dijkstra/SPFA/Floyd）
weixin_30454481的博客
02-16 576
新的整理版本版的地址见我新博客http://www.hrwhisper.me/?p=1952 一、Dijkstra Dijkstra单源最短路算法，即计算从起点出发到每个点的最短路。所以Dijkstra常常作为其他算法的预处理。 使用邻接矩阵的时间复杂度为O(n^2),用优先队列的复杂度为O((m+n)logn)近似为O(mlogn) (一) 过程 每次选择一个未访...
算法基础之Dijkstra、bellman-ford、spfa、Floyd
qq_37448336的博客
11-18 474
目录1、大纲2、单源最短路径2.1、Dijkstra 正权边2.1.1 朴素Dijkstra做法2.1.2、堆优化后的dijkstra算法2.2、bell-man ford 负权边2.2.1、有边数限制的最短路2.3、 spfa 负权边2.3.1、spfa求最短路2.3.2、spfa判断负环3、多源最短路径 floyd 1、大纲 2、单源最短路径 2.1、Dijkstra 正权边 2.1.1 朴素Dijkstra做法 #include <cstring> #include <iostre
图的最短路径：Dijkstra、Bellman-Ford、SPFA、Floyd、A*算法
jinzhao1993的博客
04-15 1万+
Dijkstra算法1.定义概览Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。注意该算法要求图中不存在负权边。问题描述：在无向图 G=(V,E) 中，假设每条边 E[i] 的长度为 w[i]，找到由顶点 V0 到其余各点的最短路径。（单源最短路径）2.算法描述求下图中的1号顶点到2、3、
最短路徑算法详解：Dijkstra、Floyd、Bellman-Ford与SPFA
本文档是关于最短路问题的教程，涵盖了Dijkstra算法、Floyd算法、Bellman-Ford算法以及SPFA算法。这些算法都是解决图论中的经典问题，旨在寻找网络中两点间的最短路径或者所有点对的最短路径。 最短路徑問題是图论...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值