最短路算法复习笔记(dijkstra/Bellman_ford/Spfa/floyd)

最新推荐文章于 2024-11-03 21:27:26 发布

Roantic

最新推荐文章于 2024-11-03 21:27:26 发布

阅读量85

点赞数

分类专栏：算法文章标签：算法笔记

本文链接：https://blog.csdn.net/Roantic/article/details/131770935

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文介绍了几种常见的最短路算法，包括Dijkstra的朴素实现和堆优化，Bellman-Ford算法以及SPFA算法，同时提到了多源最短路的Floyd算法。这些算法分别适用于不同的图结构和边权情况，如负边权、正边权、稀疏图和稠密图等。

摘要由CSDN通过智能技术生成

在这里插入图片描述
图片总结取自AcWing，仅用于个人复习
https://www.acwing.com/solution/content/6976/
以上是复习参考图原博主的文章；
以下模板也均来自AcWing模板练习题的个人理解，谨慎参考，如有错误欢迎指正。

最短路问题

单源最短路

朴素Dijkstra(n^2)-稠密常用-贪心证明-正边权

思路概括：
1.先初始化第一个结点的距离为零，其他点皆为无穷大。
2.进行n次迭代，每一次将集合外的一个到起点的距离最小的点加入到集合中，不断更新邻接点的距离，最终完成后输出的终点即为我们要找的最短距离；

#include<bits/stdc++.h>
using namespace std;
const int N=510;
int g[N][N];
bool st[N];
int dist[N];
int n,m;
int Dijkstra(){
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;//初始化一号结点的距离为0
	
	for(int i=0;i<n;i++)
	{ //遍历n次
		int t=-1;
		for(int j=1;j<=n;j++)
		{
			if(!st[j]&&(dist[t]>dist[j]||t==-1))//未被标记并且距离更小则更新
			t=j;
		}
		st[t]=true; //标记
		for(int j=1;j<=n;j++)
		{
			dist[j]=min(dist[j],dist[t]+g[t][j]);//更新取较短距离操作
		}
	}
	if(dist[n]==0x3f3f3f3f) return -1;
	return dist[n]; 
}
int main()
{
	cin>>n>>m;
	memset(g,0x3f,sizeof g);
	while(m--)
	{
		int x,y,z;
		cin>>x>>y>>z;
		g[x][y]=min(g[x][y],z);
	}
	cout<<Dijkstra()<<endl;
	return 0;
}

堆优化Dijkstra(mlogn)-稀疏图常用-贪心证明-正边权

思路：
1，将第一个点的距离初始化为0，其他点依旧是无穷大；
2，创建一个堆，并且将第一个点放入堆中；
3，在堆不为空的情况下不断循环，每次将堆顶弹出，与朴素版相同，找到集合外距离最短的点进行标记后用来更新距离，更新成功后加入到堆中；

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
const int N=1e6+5;
int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N];
bool st[N];//用于表示这个点的最短路径是否确定
void add(int a,int b,int c){
	e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int Dijkstra()
{
	memset(dist,0x3f,sizeof dist);
	dist[1]=0;
	priority_queue<PII,vector<PII>,greater<PII> > heap;//定义一个小根堆
    //用pair是因为从堆中取出需要直到两点，一代表的是距离，二代表的是这是哪个点
	heap.push({0,1});
	while(heap.size()){
		PII t=heap.top();//不在集合中的最短距离的点
		heap.pop();//弹出
		
		int v=t.second;//代表哪个点
		int distance=t.first;//代表距离
		
		if(st[v]) continue;//若是已经标记
		st[v]=true;//标记
		
		for(int i=h[v];i!=-1;i=ne[i]){
			int j=e[i];
			if(dist[j]>dist[v]+w[i])
			{
				dist[j]=dist[v]+w[i];//更新最短距离操作
				heap.push({dist[j],j});//加入堆中
			}
		}
	}
	if(dist[n]==0x3f3f3f3f )return -1;
	return dist[n];
}
int main()
{
	cin>>n>>m;
	memset(h,-1,sizeof h);
	while(m--){
		int a,b,c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	cout<<Dijkstra()<<endl;
	return 0;
}

Bellman_ford-O(nm)-常用有次数限制-离散数学证-负边权

思路：
1，初始化数组dist为无穷大，dist[1]=0;
2，外重循环遍历n次；
3，内重循环遍历m次；把所有边都进行松弛操作；
4，返回答案

#include<bits/stdc++.h>
using namespace std;
const int N=510,M=10010;
struct edge{
	int a,b,c;
}edges[M];
int n,m,k;
int dist[N];
int last[N];
void bellman_ford(){
	memset(dist,0x3f,sizeof(dist));
	
	dist[1]=0;
	for(int i=0;i<k;i++)
	{
		memcpy(last,dist,sizeof dist);
		for(int j=0;j<m;j++){
			auto e=edges[j];
			dist[e.b]=min(dist[e.b],last[e.a]+e.c);
		}
	}
}
int main()
{
	cin>>n>>m>>k;
	for(int i=0;i<m;i++){
		int a,b,c;
		cin>>a>>b>>c;
		edges[i]={a,b,c};
	}
	bellman_ford();
	if(dist[n]>0x3f3f3f3f/2) puts("impossible");
	else cout<<dist[n]<<endl;
	return 0;
}

Spfa-最好O(n),最坏O(nm)-同上-正负边权

1.建立一个队列，最开始队列中只有起点；
2.再建立一个数组记录起点到所有点的最短距离；
3.建立st[]数组标记判断点是否在队列中；
4.队头不断出队，计算起点经过对头再到邻点的距离，若更小则入队；
5.重复直到队列为空后在保存最短路径数组中，就得到了最短路径。

所谓松弛操作：

即为有三个点a,b,c;

a可以直接到c,也可a到b再到c；

比较a->b和a->b->c哪个大；

若是前者较大，则说明当前的不是最短路，就要将后者的值赋为最短的距离；

这就是松弛操作。

#include<bits/stdc++.h>
#include<queue>
using namespace std;
const int N=1e5+10;
int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N];
bool st[N];
void add(int a,int b,int c)
{
	e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int spfa()
{
	memset(dist,0x3f,sizeof dist);//将距离全部初始化
	dist[1]=0;//仅起点初始化为0
	
	queue<int>q;
	q.push(1);//将第一个点也就是起点入队
	st[1]=true;//判断当前的点已经加入到队列当中了
	
	while(q.size()){ //当队列不为空
		int t=q.front(); //取队首
		q.pop(); //弹出
		st[t]=false;//标记当前的点已经出队
		for(int i=h[t];i!=-1;i=ne[i])//遍历与其相连的其他结点
		{
			int j=e[i];
			if(dist[j]>dist[t]+w[i]) //若是当前点j的距离较大
			{
				dist[j]=dist[t]+w[i];//则执行更新操作也就是松弛操作
				if(!st[j]) //若是没有走过
				{
					q.push(j);//入队
					st[j]=true;
				}
			}
		}
	}
	return dist[n];//返回的是从起点到点n的距离
}
int main()
{
	scanf("%d%d",&n,&m);
	memset(h,-1,sizeof h);
	while(m--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		add(a,b,c);
	}
	int t=spfa();
	if(t==0x3f3f3f3f) puts("impossible");
	else cout<<t<<endl;
	return 0;
}

多源最短路

Floyd-O(n^3)-动态规划证

1.初始化d[i][j]表示的是i到j的距离;
2.起点d[i][j]=0,其他点d[i][j]=INF;
3.去更新d;

#include<bits/stdc++.h>
using namespace std;
const int N=210,INF=1e9;
int n,m,k,x,y,z;
int d[N][N];
void floyd()
{
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
			d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    		//比较i到j的距离和i到k再k到j的距离，取较小的值为最短距离;
}
int main()
{
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		if(i==j) d[i][j]=0;//起点的距离初始化为0
		else d[i][j]=INF;//其他点的距离全部初始化为无穷大
	while(m--)
	{
		cin>>x>>y>>z;	//更新两点之间的最短路径长度
		d[x][y]=min(d[x][y],z); //因为有重边，若没有重边则直接等于z
	}
	floyd();
	while(k--){
		cin>>x>>y; //因为题目是具有负边权的，所以取INF/2;
		if(d[x][y]>INF/2) //若是没有负边权则直接取INF；
            puts("impossible");
		else
			cout<<d[x][y]<<endl;
	}
	return 0;
}