SPFA算法 (Shortest Path Faster Algorithm)

SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同，为 O(VE)。

简述原理

对于当前的一个点i，遍历与他直接相连的每一个顶点j，如果从源点到j的“最短”距离（之前记录的）大于从源点经由i再到j的距离，用后者更新前者（松弛），并且记录路径。从源点作为当前点开始，依次按上述方法遍历每一个连通点，最后得到的便是源点到其他所有点的最短距离

示例

下面是一个无向图的示例程序

#include <cstdio>
#include <queue>
#include <iostream>
using namespace std;
const int MAXN = 100+10;
const int INF = 0x7fffffff;
static int sq[MAXN][MAXN];
int pre[MAXN];
void path(int x)
{
	if (pre[x] != x)
		path(pre[x]);
	printf("%d -> ", x);
	
}
int* SPFA(int n,int ori,int sq[][MAXN])  //这里默认sq中无连接的两个点距离为INF,节点的编号0-n-1
{
	static int dis[MAXN];	//用于保存Ori到每个顶点的最短距离
	int vis[MAXN];			//标识某个顶点是否在队列中，防止反复入队
	queue<int> team;		//处理队列
	memset(vis,0,sizeof(vis));	
	memset(dis, 0x3f, sizeof(dis)); //到每个顶点的最短距离初始化为无穷大
	dis[ori] = 0;	pre[ori] = ori;				//ori到自身的最短距离是0,无前驱 
	vis[ori] = 1; team.push(ori);	//ori入队
	while (!team.empty())	
	{
		int x = team.front(); team.pop();	//从队首取出一个顶点
		for (int i = 0;i < n;i++)			//遍历与该顶点x直接相连的其他顶点i(0->n-1)
		{
			if (dis[x] + sq[x][i] < dis[i])	//松弛
			{
				dis[i] = dis[x] + sq[x][i];
				pre[i]=x;        //记录前驱，保存路径
				if (!vis[i])	//如果i不在队列中，让其入队
				{
					team.push(i);	vis[i] = 1;
				}
			}
		}
		vis[x] = 0;
	}
	return dis;	
}
void init(int n, int m,int sq[][MAXN])
{
	int x, y, w;
	for (int i = 0;i < m;i++)
	{
		scanf("%d%d%d",&x,&y,&w);
		sq[x][y] = w;				
		sq[y][x] = w;				//若为有向图则无此行
	}
	
}
int main()
{

	int n, m;
	static int sq[MAXN][MAXN];
	memset(sq,0x3f,sizeof(sq));
	cin >> n >> m;
	init(n,m,sq);
	int *dis=SPFA(n,0,sq);
	for (int i = 0;i < n;i++)
		printf("[%d] : %d\n",i,dis[i]);
	for (int i = 1; i < n; i++)
	{
		path(i);
		printf("\n");
	}
	return 0;
	
}

附上一组测试数据，以供检验代码的正确性：

5 7
0 1 5
0 3 7
1 2 3
1 3 4
1 4 9
2 4 5
3 4 3

answer
[0] : 0
[1] : 5
[2] : 8
[3] : 7
[4] : 10