最短路各算法总结

最新推荐文章于 2022-06-25 21:48:27 发布
最新推荐文章于 2022-06-25 21:48:27 发布
阅读量303 收藏 1
点赞数
分类专栏： 基础算法 文章标签： 最短路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z7784562/article/details/103077471
版权

个人建议：先学存图再看算法
先看：

文章目录

Floyd算法

适用情况：

求任意两点间的最短路，不能处理负权回路（负权环)，可处理负权边。

时间复杂度：

O(N3)

算法思想：

如果要两点a,b间的路程变短，就需要引入新的顶点k1，k2,……kn，使a—>k1—>k2—>……—>kn—>b更短。 即对a和b之间所有的其他点进行松弛。
DP：状态状态转移方程：d[k][i][j] = min(d[k-1][i][j], d[k-1][i][k]+d[k-1][k][j])
利用滚动数组优化：a[i][j]=min(a[i][j],a[i][k]+a[k][j])【动态规划：0/1背包问题】
相关文章：https://blog.csdn.net/qq_40507857/article/details/80657007

代码：

#include<bits/stdc++.h>
const int maxn=99999999;
using namespace std;
int a[100][100];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int i,j,k,n,m,t1,t2,t3;
	cin>>n>>m;
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(i==j)
				a[i][j]=0;
			else
				a[i][j]=maxn;
	for(i=1;i<=m;i++)
	{
		cin>>t1>>t2>>t3;
		a[t1][t2]=t3;
	}
	//Floyd-Warshall算法核心
	for(k=1;k<=n;k++)
		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)
				if(a[i][j]>a[i][k]+a[k][j])
					a[i][j]=a[i][k]+a[k][j];
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=n;j++)
			cout<<a[i][j]<<" ";
		cout<<endl;
	 } 
	return 0;
}

Dijkstra算法

适用情况：

求从一个顶点到其余各顶点的最短路径算法，不能处理负权边。

时间复杂度：

O(N2)
利用堆优化；在边数M少于N^2的稀疏图来说，可以用邻接表代替邻接矩阵。可优化为O((M+N)logN)。

算法思想：

类似BFS+贪心。通过边来松弛1号顶点到其余各点的距离。选择离起点最近的一个点，扩散出去。
选择距离1号顶点最近的一个顶点作为确定的长度（因为边权值非负，所以距离1号顶点距离最短即意味着不可能通过其他的点中转来缩短距离。然后讨论从已选的点i到其他点j的距离是否能够更短，即dis[j]=min(dis[j],dis[i]+a[i][j])。
如果book数组的值全为1，则1号点到所有的点的距离确定，即1号点到所有点的最短距离确定。

代码：

#include<bits/stdc++.h>
const int maxn=99999999;
using namespace std;
int a[100][100],dis[100],book[100];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int i,j,n,m,t1,t2,t3,u,v,min1;
	cin>>n>>m;
	//初始化
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(i==j)
				a[i][j]=0;
			else
				a[i][j]=maxn;
	for(i=1;i<=m;i++)
	{
		cin>>t1>>t2>>t3;
		a[t1][t2]=t3;	
	} 
	//初始化dis数组，表示1号顶点到其余各点的距离
	for(i=1;i<=n;i++)
		dis[i]=a[1][i];
	//初始化book数组，book数组表示从1号顶点到其他顶点的距离是否确定，确定为1，不确定为0
	for(i=1;i<=n;i++)
		book[i]=0;
	book[1]=1;
	//dijkstra算法核心语句
	for(i=1;i<=n;i++)
	{
		min1=maxn;
		for(j=1;j<=n;j++)
			if(book[j]==0 && dis[j]<min1)
			{
				min1=dis[j];
				u=j;
			}//找出离1号顶点最近的顶点 
		book[u]=1;//这个点到1号顶点的距离即是最短距离，将它标记为确定的距离。
				  //因为所有的边权值都非负。 
				  //所以对于距离1号顶点距离最短的一个点，无法通过其他点的中转来获得更短的距离。 
		for(v=1;v<=n;v++)
			if(a[u][v]<maxn)
				dis[v]=min(dis[v],dis[u]+a[u][v]);
		//在u->v的距离不为无穷大时，即从u到v有路时，判断是否能够通过中转来缩短距离。 
	} 
	for(i=1;i<=n;i++)
		cout<<dis[i]<<" "; 
	return 0;
}

优化：

堆优化：

优化思想：

用堆每次弹出最小值来代替每轮进行的最短边查找。堆用小根堆，可以保证每次在堆顶的元素是最小的。可以使时间复杂度降为O(M+NlogN)。

代码：
//注：手打的代码模板，不保证正确性QAQ 
#include<bits/stdc++.h>
const int inf=99999999;
using namespace std;
int vis[1000],maze[1000][1000],dis[1000];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int n,m,i,j;
	int a,b,c;
	priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > que; 
	//优先队列，用pair第一个值存权值，第二个值存点下标，greater是从按权值小到大排序，即小根堆。 
	cin>>n>>m;
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(i==j) maze[i][j]=0;
			else maze[i][j]=inf;
	for(i=1;i<=m;i++)
	{
		cin>>a>>b>>c;
		maze[a][b]=c;	
	}
	memset(vis,0,sizeof(vis)); 
	for(i=1;i<=n;i++)
		dis[i]=maze[1][i];//初始化dis数组 
	que.push(make_pair(0,1));//将第一个点放入优先队列 
	while(!que.empty())
	{
		int k;
		int pre=que.top().second;//pre表示pair的第二个值，即对这个点的边进行松弛操作 
		que.pop();
		if(vis[pre])
			continue;
		vis[pre]=1;
		for(k=1;k<=n;k++)
			if(maze[pre][k]<inf)
				if(dis[k]>=dis[pre]+maze[pre][k])//如果可以进行松弛操作，就将可以改变的点放入优先队列 
				{
					dis[k]=dis[pre]+maze[pre][k];
					que.push(make_pair(dis[k],k));
				}
	}
	for(i=1;i<=n;i++)
		cout<<dis[i]<<" ";
	return 0;
}

堆优化+链式前向星：

//注：手打的代码模板，不保证正确性QAQ 
#include<bits/stdc++.h>
#define pii pair<int,int>
const int N=1e5+10;
const int inf=99999999;
using namespace std;
struct edge
{
	int next,to,w;
}maze[N];
int head[N]={0},len=0,vis[N]={0},dis[N];
void add(int u,int v,int w)
{
	maze[++len]={head[u],v,w};
	head[u]=len;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int n,m,i;
	cin>>n>>m;
	for(i=1;i<=m;i++)
	{
		int u,v,w;
		cin>>u>>v>>w;
		add(u,v,w);
		add(v,u,w);
	}
	for(i=1;i<=n;i++)
		dis[i]=inf;
	dis[1]=0;
	priority_queue<pii,vector<pii>,greater<pii> >que;
	que.push(make_pair(0,1));
	while(!que.empty())
	{
		int pre=que.top().second;
		que.pop();
		if(vis[pre])
			continue;
		vis[pre]=1;
		for(i=head[pre];i;i=maze[i].next)
		{
			int v=maze[i].to,w=maze[i].w;
			if(dis[v]>dis[pre]+w)
			{
				dis[v]=dis[pre]+w;
				que.push(make_pair(dis[v],v));
			}
		}
	}
	for(i=1;i<=n;i++)
		cout<<dis[i]<<" "; 
	return 0;
}

Ford算法

适用情况：

可以解决带负权边的图，可以判断是否存在负权回路（负权环）。

时间复杂度：

O(NM)
优化：可以用check来判断dis数组在本轮循环中是否发生变化。如果dis数组没有发生变化，即所求已经是最短路径，即可跳出循环。

算法思想：

对所有的边进行n-1次松弛操作。
进行k次松弛后，我们可以得到1号点最多经过k条边到其余点的最短距离。
能否通过u[i]->vi的边使1号顶点到v[i]的距离缩短，即：dis[v[i]]=min(dis[v[i]],dis[u[i]]+w[i])。
对于正权回路，去掉的话，我们肯定可以得到更短的距离。
对于负权回路，每循环一次都会得到更短的距离。所以我们可以通过进行n-1次循环之后，能不能继续松弛来判断图中是否存在负权回路。

代码：

#include<bits/stdc++.h>
const int maxn=99999999;
using namespace std;
int dis[100],u[100],v[100],w[100],bak[100];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int i,k,n,m,check,flag;
	cin>>n>>m;
	//读入数据，即从边u[i]->v[i]的距离w[i] 
	for(i=1;i<=m;i++)
		cin>>u[i]>>v[i]>>w[i];
	//初始化dis数组
	for(i=1;i<=n;i++)
		dis[i]=maxn;
	dis[1]=0; 
	//Ford算法核心语句
	for(k=1;k<=n-1;k++)
	{
		check=0;//记录本轮dis数组是否会更新
		//进行松弛
		for(i=1;i<=m;i++)
			if(dis[v[i]]>dis[u[i]]+w[i]) //对于1号点到v[i]号点,是否存在u[i]点中转使距离更短 
			{
				dis[v[i]]=dis[u[i]]+w[i];
				check=1;
			}
		if(!check)
			break; 
	} 
	//检查负权回路
	flag=0;
	for(i=1;i<=m;i++)
		if(dis[v[i]]>dis[u[i]]+w[i]) //如果再进行n-1次松弛后，仍然能松弛，即含有负权环。 
			flag=1;
	if(flag)
		cout<<"此图含有负权回路"<<endl; 
	else
		for(i=1;i<=n;i++)
			cout<<dis[i]<<" "; 
	return 0;
}

SPFA算法（Ford算法的队列优化）

适用情况：

同Ford算法。

时间复杂度：

最坏情况O(NM)

算法思想：

用邻接表存图；队列操作。
取出队首，对其出边进行松弛操作，将最短路径能够发生改变的点放入队尾。用数组book标识当前那些点已在队列中。
形式上有些类似于BFS。
对于负环的判定：如果一个点进入队列的次数大于等于n-1次，那么就存在负权环。

代码：

#include<bits/stdc++.h>
const int maxn=99999999;
using namespace std;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	int n,m,i,j,k;
	int u[8],v[8],w[8];//储存边u[i]->v[i]的权值w[i] 
	int first[6],next[8];
	int dis[6]={0},book[6]={0};
	int que[101]={0},head=1,tail=1;//定义队列
	cin>>n>>m;
	for(i=1;i<=n;i++)
		dis[i]=maxn;
	dis[1]=0;
	for(i=1;i<=n;i++)
		first[i]=-1;//初始化first数组，表示1~n顶点暂时没边
	for(i=1;i<=m;i++)
	{
		cin>>u[i]>>v[i]>>w[i];
		//建立邻接表 
		next[i]=first[u[i]];
		first[u[i]]=i; 
	} 
	que[tail++]=1;
	book[1]=1;//1号顶点入队
	while(head<tail)
	{
		k=first[que[head]];//当前要处理的队首顶点
		while(k!=-1)//扫描当前顶点所有边 
		{
			if(dis[v[k]]>dis[u[k]]+w[k])
			{
				dis[v[k]]=dis[u[k]]+w[k];
				if(book[v[k]]==0)
				{
					que[tail++]=v[k];
					book[v[k]]=1;
				}
			} 
			k=next[k];
		} 
		book[que[head]]=0;
		head++;//出队 
	} 
	for(i=1;i<=n;i++)
		cout<<dis[i]<<" ";
	return 0;
}

用链式前向星的代码：

//手打模板，不保证正确性,QAQ.
#include<bits/stdc++.h>
const int inf=99999999;
using namespace std;
struct edge
{
	int next,to,w;
}maze[1000];
int head[100],dis[100],vis[100],num[100];
int len=0,n,m;
void add(int u,int v,int w)
{
	maze[++len]={head[u],v,w};
	head[u]=len;
}
int spfa()
{
	queue<int> que;
	que.push(1);
	while(!que.empty())
	{
		int pre=que.front(),i;
		que.pop();
		vis[pre]=0;
		for(i=head[pre];i;i=maze[i].next)
		{
			int v=maze[pre].to;
			if(dis[v]>dis[pre]+maze[i].w)
			{
				dis[v]=dis[pre]+maze[i].w;
				if(!vis[v])
				{
					num[v]++;
					if(num[v]>=n)
						return 1;//如果入队次数大于n表示有负环。 
					vis[v]=1;
					que.push(v);
				}
			}
		}
	}
	return 0;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);cout.tie(0);
	memset(vis,0,sizeof(vis));
	memset(num,0,sizeof(num));//记录一个顶点的入队次数。 
	memset(head,0,sizeof(head));
	int i;
	cin>>n>>m;
	for(i=1;i<=n;i++)
		dis[i]=inf;
	for(i=1;i<=m;i++)
	{
		int a,b,c;
		cin>>a>>b>>c;
		add(a,b,c);
//		add(b,a,c);//无向图 
	}
	dis[1]=0;
	vis[1]=1;
	num[1]=1;
	if(spfa())
		cout<<"含负环"<<endl;
	else 
		for(i=1;i<=n;i++)
			cout<<dis[i]<<" "; 
	return 0;
}

相关题目题解

会飞的小蛇
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
最短路算法
09-29
最短路算法讲义，主要是以PPT的形式对最短路算法进行详细的描述与总结。
四种最短路算法的比较
石旭先森的博客
06-01 1201
推荐阅读原文：https://blog.csdn.net/mashiro_ylb/article/details/78289790 结论是： Dijkstra算法，不能处理存在负边权的情况，侧重对点的处理，适用于：稠密图。 Floyed-Warshall算法，只有数据规模较小且时空复杂度都允许时才可以使用。 Bellman-Ford算法，可以求出存在负边权情况下的最短路径，但无法解决存在负权回路...
最短路算法总结（超详细~）
热门推荐
wmy0217_的博客
04-11 3万+
文章目录最短路算法框架朴素Dijkstra算法堆优化版Dijkstra算法 最短路算法框架 最短路有五种算法，分别适用不同的情况。 单源最短路： 求一个点到其他点的最短路 多源最短路： 求任意两个点的最短路 稠密图用邻接矩阵存，稀疏图用邻接表存储。 稠密图： m 和 n2 一个级别 稀疏图： m 和 n 一个级别 朴素Dijkstra算法 Dijkstra算法是通过 n 次循环来确定 n 个点...
五大最短路算法总结
qq_34771124的博客
09-20 411
最短路算法总结 目录 1.Floyd（n^3) 2.bellman-ford(nm) n: 点数 m:边数 3.dijikstra(n^2) n：点数 4.spfa(Km) K:约为2的常数 m:边数 5.Johnson
最短路算法详解
qq_59539549的博客
06-25 2470
图的最短路算法
最短路算法总结
m0_61734125的博客
05-08 233
最近一周为了省ACM准备，系统地学习了一下最短路算法。 大致有三种Dijkstra算法、Bellman-ford算法、Floyd算法。 下面就三种算法的适用范围以及代码详解做出描述。 首先Dijkstra算法 朴素Dijkstra算法是最简单、易上手的一个处理最短路的算法，当然代码也很容易理解，即使对于算法小白也很容易掌握，但是缺点是时间复杂度是O（n^2），一般对于小于等于1e3次方的点数可以使用，对于再大的就会超时。 对于朴素Dijkstra算法我完成了以下几道题目，以下就题目思路与代码展开讨
求最短路的算法及相关问题概述总结报告
05-18
求最短路的算法及相关问题概述总结报告
两年ACM竞赛所有算法总结.docx
04-05
两年ACM竞赛所有算法总结，这里包含最短路、最小生成树、动态规划、字符串匹配、博弈、大数、Hash、排序、二分匹配、并查集、最大流、欧拉函数、扩展欧几里得等
Matlab各种常见算法代码总结
09-18
各种常见算法问题的代码总结，全部是用matlab语言编写。代码包括：Floyd最短路算法、hamilton回路、背包问题_遗传算法解决、旅行商TSP问题、最小费用流、聚类分析等等。
常用算法代码
09-11
| BELLMANFORD 单源最短路 O(VE) 4 | SPFA(SHORTEST PATH FASTER ALGORITHM) 4 | 第 K 短路（DIJKSTRA） 5 | 第 K 短路（A*） 5 | PRIM 求 MST 6 | 次小生成树 O(V^2) 6 | 最小生成森林问题(K 颗树)O(MLOGM). ...
（完全背包）洛谷P1616疯狂的采药
Z7784562的博客
01-07 504
洛谷P1616疯狂的采药 思路： 完全背包的板子题。 代码： #include<bits/stdc++.h> const int N=1e6+10; const int mod=1e7+9; const int maxn=0x3f3f3f3f; const int minn=0xc0c0c0c0; const int inf=99999999; using namespace std;...
（背包）AtCoder153E-Crested Ibis vs Monster
Z7784562的博客
01-27 424
AtCoder153E-Crested Ibis vs Monster 思路： 两天没写代码真的状态好差。 完全背包。 代码： #include<bits/stdc++.h> #define pii pair<int,int> #define ll long long #define cl(x) memset(x,0,sizeof(x)) const int N=1e5+1...
（位运算）牛人的题目
Z7784562的博客
11-22 425
（位运算）牛人的题目[swustxxoj1017] 题目： In the new year party, everybody will get a “special present”.Now it’s your turn to get your special present, a lot of presents now putting on the desk, and only one of t...
最短路题目题解
Z7784562的博客
11-26 361
POJ2387(dijkstra) POJ1502(floyd) POJ1847(floyd) POJ3268(dijkstra+反向存图)
（SPFA的SLF优化）AcWing342道路与航线
Z7784562的博客
01-20 358
AcWing342道路与航线 思路： 看起来非常裸的spfa，然而精心构造的数据卡了。 就用到spfa的SLF优化，我们之前的spfa都是用队列实现的，每个数据都放到队尾。现在我们用双端队列，如果当前点的权值少于我们当前队头点的权值的话,那么我们就将这个节点插入到队头,否则我们插入到队尾。 代码： #include<bits/stdc++.h> #define pii pair<...
[POJ2253]（最大权值边的最小值）Frogger
Z7784562的博客
12-02 358
POJ2253 Frogger Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on another stone. He plans to visit her, but since the water is dirty and full ...
（数学）洛谷P1062 数列
Z7784562的博客
02-01 315
洛谷P1062 数列 思路： 挺有意思的一个题目。刚开始的想法是枚举ki,然后把ki和数列前面的数相加。但是后来注意到每个数列的序号的二进制，可以发现： 1 3 4 9 10 12 13 30 31 30+31 32 30+32 31+32 30+31+32 1 10 11 100 101 110 111 数列的值就是数列编号的二进制数位i的值*ki-1。 代码： #inc...
Johnson全源最短路
Z7784562的博客
09-03 286
Johnson全源最短路 思路： 对于NNN个顶点MMM条边的图怎么求全源最短路？ Floyd，时间复杂度O(N3)O(N^3)O(N3)。 NNN次Bellman-Ford/SPFA,以每个顶点为源点跑一遍，时间复杂度O(N2M)O(N^2M)O(N2M),在稠密图中比Floyd还慢，即使尝试一些如SLF的玄学优化也会被特定数据卡掉。 NNN次Dijkstra，时间复杂度O(NMlog⁡M)O(NM\log M)O(NMlogM),弊端是无法处理负边权。 那么是不是可以考虑把所有边权变非负？ 考虑如果
遗传算法最短路最大流问题
最新发布
08-12
遗传算法可以用于解决最短路和最大流问题。在最短路问题中，我们可以将每...总结起来，遗传算法可以通过优化适应度函数来求解最短路和最大流问题。个体表示路径或流量分配方案，通过选择、交叉和变异等操作搜索最优解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值