最短路（Dijkstra, Bellman-Ford, SPFA, Floyd）

最新推荐文章于 2024-05-04 22:59:00 发布

小满M

最新推荐文章于 2024-05-04 22:59:00 发布

阅读量1.7k

点赞数 27

分类专栏： ACM 文章标签：算法 c++ 图论

本文链接：https://blog.csdn.net/m0_50269977/article/details/138247153

版权

ACM 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

最短路

Dijkstra算法（复杂度 $O (m l o g n)$ / $O (nm l o g n)$ ）–不能有负权边，不能有负权环，单源最短路径( $O (m l o g n)$ )，多源最短路径( $O (nm l o g n)$ )。
Bellman-Ford算法（复杂度 $O (nm)$ ）—能有负权边，不能有负权环，单源最短路径，有边数限制的最短路。
SPFA算法（复杂度 $O (km)$ ）—能有负权边，不能有负权环，单源最短路径
Floyd（复杂度 $O(n^3)$ ）—可以求多源最短路，可以处理负权图，不可处理有负权环的图！

Dijkstra

Dijkstra-数据结构：三个数据结构

int dis[10004],vis[10004];
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> q;

//各个数据结构的作用讲解：
dis[]:
vis[]:模拟了一个集合，vis[i]=1表示顶点 i 被加进vis集合中，vis[i]=0表示顶点 i 未被加进集合中。
q:注意优化队列一定要放pair<int,int>，并且前面一定要是距离，后面才是点！被放进去的点是有可能可以用来更新其他点的。

Dijkstra-初始化：

memset(dis,0x3f,sizeof dis); //dis数组应该初始化为无穷 
memset(vis,0,sizeof vis);

Dijkstra-预处理：

dis[i]=0; 
//vis[i]=1; //注意！不能加这一步。 
q.push({0,i}); //<长度,点>

Dijkstra-核心代码：

while(q.size())
{
	pair<int,int> tmp=q.top();
	q.pop();
	int t=tmp.second;
	if(vis[t]==1) continue;
	vis[t]=1;
	for(int i=head[t];i;i=nxt[i])
	{
		if(vis[to[i]]==0 && dis[t]+w[i]<dis[to[i]])
		{
			dis[to[i]]=dis[t]+w[i];
			q.push({dis[to[i]],to[i]});
		}
	}
}

Dijkstra-最后得到的东西：
一个dis[]数组，记录着起点i到其余各顶点的最短距离。

算法复杂度：
应该是O(nlog n)

好题：
旅行

旅行从城市 $1$ 到城市 $n$ , 一天游玩一个城市。点与点之间有一些固定费用的路，但每隔一天需要多付出 $w$ 的费用测核酸。求最少花费。

#include <bits/stdc++.h>
using namespace std;

#define int long long
#define pii pair<int,int>
#define se second
#define fi first
#define pb push_back
const int N=1e5+5;
int n,m,x;
int dis[N][2],vis[N][2];
vector<pii> v[N]; //<点，距离> 
priority_queue<pair<int,pii>,vector<pair<int,pii>>,greater<pair<int,pii>>> q;

void Dij()
{
	memset(dis,0x3f,sizeof dis);
	memset(vis,0,sizeof vis);
	dis[1][0]=0;
	q.push({0,{1,0}}); //<距离，点，标志>
	while(q.size()){
		auto tmp=q.top();
		q.pop();
		int t=tmp.se.fi;
		int f=tmp.se.se;
		if(vis[t][f]==1) continue;
		vis[t][f]=1;
		for(int i=0;i<v[t].size();++i) //遍历t点相连的点
		{
			if(dis[t][f]+v[t][i].se+(f?0:x)<dis[v[t][i].fi][f^1]){
				dis[v[t][i].fi][f^1]=dis[t][f]+v[t][i].se+(f?0:x);
				q.push({dis[v[t][i].fi][f^1],{v[t][i].fi,f^1}});
			}
		} 
	}
}

signed main(){
	scanf("%lld%lld%lld",&n,&m,&x); 
	int tt,ttt,w;
	for(int i=1;i<=m;++i)
	{
		scanf("%lld%lld%lld",&tt,&ttt,&w); 
		v[tt].pb({ttt,w});
		v[ttt].pb({tt,w});
	}
	Dij();
	//len[1]=1 
	printf("%lld\n",min(dis[n][1],dis[n][0]));
}

心得：考虑清楚一个点可以由什么点去松弛得到。

Floyd

参考算法思想：从第1个到第n个点依次加入松弛计算，每个点加入进行试探枚举是否有路径长度被更改(自己能否更新路径)。顺序加入(k枚举)松弛的点时候，需要遍历图中每一个点对(i,j双重循环)，判断每一个点对距离是否因为加入的点而发生最小距离变化，如果发生改变(变小)，那么两点(i,j)距离就更改。

应用一：求任意两点间的最短路
应用二：删边，从而降低复杂度 2021CCPC女生赛 C. 连锁商店

//Floyd（弗洛伊得）算法 
特别注意！！！两点之间的距离：
D[i][j]=0  (若i==j) 
D[i][j]=inf  (若i!=j且无边相连)
D[i][j]=W[i][j]  (若i!=j且有边相连)

算法描述：
for(k=1;k<=N;k++) //中间点
	for(i=1;i<=N;i++) //起点 
		for(j=1;j<=N;j++) //终点 
		 	if(D[i][k]+D[k][j]<D[i][j])
				D[i][j]=D[i][k]+D[k][j]; //更新最小值

结束：
D[i][j]就是从i到j的最短路径的长度。 

优化：
第一层循环：for(i=1;i<=N/2;i++) ——然后 D[i][j] = D[j][i] = ...

如果是固定源点的话，就 去掉第一层循环。

Bellman-Ford

有边数限制的最短路

题意：有n个点m条边的图（图中可能存在重边和自环，边权可能为负数，可能存在负权回路），求从1号点到n号点的最多经过k条边的最短距离。如果不存在满足条件的路径，则输出 impossible。

参考代码：

#include <bits/stdc++.h>
using namespace std;

#define int long long
const int inf=0x3f3f3f3f;
const int N=510,M=1e4+4;
int n,m,k,dis[N],tmp[N];

struct edge{
	int x,y,z;
}e[M];

void bellman_ford(){ //答案存在dis里  
	for(int i=1;i<=n;++i) dis[i]=inf;
	dis[1]=0;
	for(int i=0;i<k;++i){ //限制k条边，松弛k次
		for(int j=1;j<=n;++j) tmp[j]=dis[j];
		for(int j=1;j<=m;++j){ //遍历m条边
			int u=e[j].x,v=e[j].y,w=e[j].z;
			dis[v]=min(dis[v],tmp[u]+w);
		}
	}
} 

signed main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	cin>>n>>m>>k;
	for(int i=1;i<=m;++i) cin>>e[i].x>>e[i].y>>e[i].z;
	bellman_ford(); 
	if(dis[n]>(0x3f3f3f3f/2)) cout<<"impossible\n"; //有可能边是负数 
	else cout<<dis[n]<<'\n';
}

SPFA

算法步骤

数据结构：
Dis 代表S到I点的当前最短距离。
Fa 代表S到I的当前最短路径中I之前的一个点的编号。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。
用一个布尔数组记录每一个点是否在队列中。

初始化：
开始时，Dist全部为inf,只有Dist[S]=0,Fa全部为0 。

过程：

每次迭代，取出队头的点v，依次枚举从v出发的边v->u,设边的长度为len，判断Dist[v]+len是否小于Dis[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去，直到队列变空，也就是说S到所有结点的距离都确定下来，结束算法。

算法复杂度

在平均情况下，SPFA算法的期望时间复杂度O(KM) 。M为边数，K是每个点平均入队次数。

但是，有很特殊的情况，这张图是一个棋盘格子，网格图，你的SPFA是很有可能被卡到NM的然后它就死了。所以在OI里面，有一句话，关于SPFA，它死了。

所以没有负权边，就尽量不要用它了，万一被卡了。

对比Bellman-Ford：
Bellman-Ford：每一次松弛的时候Bellman-Ford都要枚举所有的点，而其实很多点都是不需要被枚举的，所以会有很多的无效枚举，使得算法效率降低。
SPFA：其实每次松弛的时候只需要枚举与上次被松弛的点相连的点就可以了。

求最短路（含负权边）

#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 510,M = 10010;

int n,m,k;
int dist[N],backup[N]; //backup数组为上次
struct edges
{
   	int a,b,w; // a->b权值为w的边 
}edge[M];

int bellman_ford()
{
	memset(dist,0x3f,sizeof(dist));
	dist[1] = 0;
	
	for(int i=0; i<k; i++) 
	{
		memcpy(backup,dist,sizeof(dist)); //备份
		for(int j=0; j<m; j++)   // 枚举所有边 
		{
		   int a = edge[j].a, b = edge[j].b, w=edge[j].w;	
		   dist[b] = min(dist[b],backup[a]+w); // 用备份更新 
		}
	}
	if(dist[n] > 0x3f3f3f3f/2) return -1;
	return dist[n];
}
int main()
{
    cin >> n >> m >> k;
	for(int i=0; i<m; i++)
	{
	   int a,b,w;
	   cin >> a >> b >> w;
	   edge[i] = {a,b,w}; 	
	}	
	int t = bellman_ford();
	
	if(t == -1) cout << "impossible";
	else cout << t;
	return 0;
}

判断是否存在负权环

若一个点入队次数超过n，则有负权环。因为它最多被n-1个点（其他所有点）更新。所以要看是否存在负权环，用一个cnt[]数组，记录每个点的入队次数。

裸题：洛谷-P3385 【模板】负环

#include <bits/stdc++.h>
using namespace std;

const int N = 2e3+10;
const int M = 3e4+10; //开这个数，要细心一点，像无向图，它是对称存储的，如m=2，其实是需要存4条边，当m=2e3时，其实会有4e3条边，如果只开2e3会出现各种错，像re、wa等 
const int inf = 0x3f3f3f3f;
int num;
int head[N];
int to[M];
int w[M];
int ne[M];

int T,n,m,dis[N],vis[N],cnt[N];

inline void addedge(int x,int y,int z){
	to[++num]=y;
	w[num]=z;
	ne[num]=head[x];
	head[x]=num;
}

void SPFA(){
	queue<int> q;
	//初始化
	memset(dis,0x3f,sizeof dis);
	dis[1]=0;
	vis[1]=1;
	q.push(1);
	++cnt[1];
	while(q.size()){
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=head[u];i;i=ne[i]){
			if(dis[u]+w[i]<dis[to[i]]){
				dis[to[i]]=dis[u]+w[i];
				if(vis[to[i]]==0){
					q.push(to[i]);
					vis[to[i]]=1;
					++cnt[to[i]]; //入队一次就加一次。 
					if(cnt[to[i]]>=n){
						cout << "YES" << endl;
						return;
					}
				}
			}
		}
	}
	cout << "NO" << endl;
} 

int main(){
	cin >> T;
	while(T--){
		memset(head,0,sizeof head);
		memset(to,0,sizeof to);
		memset(ne,0,sizeof ne);
		memset(w,0,sizeof w);
		num=0;
		memset(vis,0,sizeof vis);
		memset(cnt,0,sizeof cnt);
		cin >> n >> m;
		for(int i=1;i<=m;i++){
			int x,y,z;
			cin >> x >> y >> z;
			addedge(x,y,z);
			if(z>=0)
				addedge(y,x,z);
		}
		SPFA();	
	}
	return 0;
}

小满M

关注

27
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
最短路（Dijkstra, Bellman-Ford, SPFA, Floyd）

每次迭代，取出队头的点v，依次枚举从v出发的边v->u,设边的长度为len，判断Dist[v]+len是否小于Dis[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去，直到队列变空，也就是说S到所有结点的距离都确定下来，结束算法。Bellman-Ford：每一次松弛的时候Bellman-Ford都要枚举所有的点，而其实很多点都是不需要被枚举的，所以会有很多的无效枚举，使得算法效率降低。
复制链接

扫一扫