3.2.4 最短路径 spfa算法

spfa算法

spfa算法是在bellman_ford算法基础上的优化（队列）

bellman算法中暴力枚举所有的边，但并不是每个点都会更新，存在无效遍历

适用范围

• 单源最短路径，带负权
• 寻找图中负权回路

算法实现

最短路径

spfa算法在更新操作时，会维护一个队列，只有更新为最短路径的点进队（与堆优化版Dijkstra相似）

拿未更新最短路径的点去更新其他点是没有意义的

同时会开数组记录进队情况，在队列的点不用重复入队

负权回路

在更新最短路径点时更新边数，如果在某时刻边数大小>=n（n个点最多n-1条边），则一条边出现了两次或多次

出现两次或多次则证明有一条回路，经过某个点最终又回到了这个点 （ i -> i ）

在求最短路径的时候，只有这个回路中权值和为负数时，才会出现回路，而自环不会影响最短路径的更新

	if(dist[t]+w[i]<dist[j]){
		dist[j]=dist[t]+w[i];
		cnt[j]=cnt[t]+1;
	}

同时还应注意，在图中可能1号点到n号点之间的最短路径不经过负权回路

所以spfa求负权回路时，是以每个点作为源点尝试求最短路径，所以dist数组开始均为0

例题 AcWing851. spfa求最短路

题目大意：

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

思路：

维护一个队列，只有更新为最短路径的点进队，直至找到1号点到n号点的最短路径

Solved：

#include <bits/stdc++.h>
#define int long long

using namespace std;
const int N=1e5+10,INF=0x3f3f3f3f;

//邻接表
int h[N],e[N],w[N],ne[N],idx;

//加边
void add(int a,int b,int c)
{
	e[idx]=b,w[idx]=c;
	ne[idx]=h[a];
	h[a]=idx++;
}

//dist:最短路径 st:判断是否在队 
int dist[N],st[N];
int n,m;

void spfa()
{
	//初始化
	memset(dist,0x3f,sizeof(dist));
	dist[1]=0;

	//队列初始化
	queue<int> q;
	q.push(1);
	st[1]=1;

	while(!q.empty()){
		int t=q.front();//前驱节点
		q.pop();
		for(int i=h[t];i!=-1;i=ne[i]){
			int j=e[i];//后继节点
			//如果前驱+边<后继，更新后继
			if(dist[t]+w[i]<dist[j]){
				dist[j]=dist[t]+w[i];
				//不在队列中就入队
				if(st[j]==0){
					q.push(j);
					st[j]=1;
				}
			}
		}
	}
	if(dist[n]==INF){
		cout<<"impossible"<<endl;
	}else{
		cout<<dist[n]<<endl;
	}
	return ;
}

signed main()
{
	//邻接表初始化
	memset(h,-1,sizeof(h));

	cin>>n>>m;
	while(m--){
		int a,b,c;cin>>a>>b>>c;
		add(a,b,c);
	}

	spfa();

	return 0;
}
/*
3 3
1 2 5
2 3 -3
1 3 4

2
*/

例题 AcWing852. spfa判断负环

题目大意：

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。请你判断图中是否存在负权回路。

思路：

以每个点作为源点尝试求最短路径，在更新最短路径点时更新边数，如果在某时刻边数大小>=n，则证明出现负权回路

Solved：

#include <bits/stdc++.h>
#define int long long

using namespace std;
const int N=1e5+10,INF=0x3f3f3f3f;

//邻接表
int h[N],e[N],w[N],ne[N],idx;

//加边
void add(int a,int b,int c)
{
	e[idx]=b,w[idx]=c;
	ne[idx]=h[a];
	h[a]=idx++;
}

//dist:最短路径 st:判断是否在队 
int dist[N],st[N];
int n,m;

//cnt:记录边数
int cnt[N];

int spfa()
{
	//初始化 ,dist均为0
	queue<int> q;
	for(int i=1;i<=n;i++){
		st[i]=1;
		q.push(i);
	}

	while(!q.empty()){
        
		int t=q.front();//前驱节点
		q.pop();

		st[t]=0;

		for(int i=h[t];i!=-1;i=ne[i]){

			int j=e[i];//后继节点

			//如果前驱+边<后继，更新后继
			if(dist[t]+w[i]<dist[j]){

				dist[j]=dist[t]+w[i];

				cnt[j]=cnt[t]+1;
				if(cnt[j]>=n) return 1;

				//不在队列中就入队
				if(st[j]==0){
					q.push(j);
					st[j]=1;
				}
			}
		}
	}
	return 0;
}

signed main()
{
	//邻接表初始化
	memset(h,-1,sizeof(h));

	cin>>n>>m;
	while(m--){
		int a,b,c;cin>>a>>b>>c;
		add(a,b,c);
	}

	int t=spfa();
	if(t==1){
		cout<<"Yes"<<endl;
	}else{
		cout<<"No"<<endl;
	}
	return 0;
}
/*
3 3
1 2 -1
2 3 4
3 1 -4
Yes
*/