spfa算法求最短路

spfa算法本质上就是对bellman_ford算法的优化。

我们先来回想一下bellman_ford算法的思想，就是每次利用每条边去尝试更新各店与源点之间的距离，无疑这样的复杂度是比较高的，那我们又该怎样进行优化呢？

先思考一个问题，假如在上一次的松弛过程中i号节点距离源点的距离未被得到更新，那我们还有没有用与i号节点相连的边去更新其他节点的必要呢，肯定是没必要的，那我们只要把之前被更新过的点存起来，用这些点去更新其他点到源点的距离的话不就实现了对bellman_ford算法的优化了么？

核心代码：

void spfa()
{
	memset(d,0x3f,sizeof d);
	d[1]=0;
	queue<int> q;
	q.push(1);//先将源点放入队列，用于更新其他点 
	vis[1]=true;//标记为在队列中 
	while(q.size())
	{
		int begin=q.front();
		q.pop();
		vis[begin]=false;
		for(int i=h[begin];i!=-1;i=ne[i])//用队列中的点去更新其他点到源点的距离 
		{
			int j=e[i];
			if(d[j]>d[begin]+w[i])
			{
				d[j]=d[begin]+w[i];
				if(!vis[j])//如果不在队列中就入队列，准备更新其他点 
				{
					q.push(j);
					vis[j]=true;
				}
			 }
		}
	}
}

下面给出一道例题：

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

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

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

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 impossible。

数据范围

1≤n,m≤10^5,
图中涉及边长绝对值均不超过 10000。

输入样例：

3 3
1 2 5
2 3 -3
1 3 4

输出样例：

2

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N=1e5+10;
int h[N],e[N],ne[N],d[N],w[N],idx;
bool vis[N];
int n,m;
void add(int x,int y,int z)
{
	e[idx]=y;
	w[idx]=z;
	ne[idx]=h[x];
	h[x]=idx++;
}
void spfa()
{
	memset(d,0x3f,sizeof d);
	d[1]=0;
	queue<int> q;
	q.push(1);//先将源点放入队列，用于更新其他点 
	vis[1]=true;//标记为在队列中 
	while(q.size())
	{
		int begin=q.front();
		q.pop();
		vis[begin]=false;
		for(int i=h[begin];i!=-1;i=ne[i])//用队列中的点去更新其他点到源点的距离 
		{
			int j=e[i];
			if(d[j]>d[begin]+w[i])
			{
				d[j]=d[begin]+w[i];
				if(!vis[j])//如果不在队列中就入队列，准备更新其他点 
				{
					q.push(j);
					vis[j]=true;
				}
			 }
		}
	}
}
int main()
{
	cin>>n>>m;
	int a,b,c;
	memset(h,-1,sizeof h);
	while(m--)
	{
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
	}
	spfa();
	if(d[n]>0x3f3f3f3f/2) puts("impossible");
	else printf("%d",d[n]);
	return 0;
} 

这就是spfa算法求醉短路的方法，如果有错误，欢迎大家在评论区中指出！