SPFA(bellman-ford+队列优化)

SPFA：这个也是一种最短路算法，他的优点在于，可以解决所有最短路的问题。无论是权值为负或者为正。时间也比bellman-ford和普通的迪杰斯特拉要快。所以可以用这个算法来解决大部分最短路的问题。

SPFA是在bellman-ford算法上加一个队列优化。

先回顾一下bellman-ford的思路：反复用已拥有的边来更新新的边。如果已确定的边v，和未确定的边u，若dist【u】 >= dist【u】+ map【u】【v】，那么就更新dist【u】。

SPFA：设立一个先进先出的队列来保存待优化的点。优化时，取出队首点，并用这个点的当前最短路的估计值来对离开这点所指向的节点进行松弛操作。若那个点被松弛了，那就把这点加入队列。，然后循环这个取队首点的过程。

这个和bellman-ford的做法是有一点区别，前者是把所用的边来找一遍。无论是否发生改变。而spfa则是只对发生变化的点来操作。这样省去很多不变边的操作。时间复杂度要降下去很多。当然了这个和迪杰斯特拉+优先队列优化来比还是差一点。因为不确定性。

这个算法也可以算判断负环。如果某个点弹出队列的次数超过N-1次，则存在负环。

上一个求最短路的代码（链式前向星）。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;

const int maxn = 300001;
const int inf = 0xffffff;
struct edge{
	int from;
	int to;
	int w;
	int next;
}e[1000001];

int head[maxn];
int vis[maxn];
int dist[maxn];
int n,m,t;

void add(int i,int j,int w){
	e[t].from = i;
	e[t].to = j;
	e[t].w = w;
	e[t].next = head[i];
	head[i] = t++;
}
void spfa(int s){
	queue<int> q;
	for(int i = 1; i <= n ; i++)
		dist[i] = inf;
	memset(vis,false,sizeof(vis));
	q.push(s);
	dist[s] = 0;
	while(!q.empty()){
		int u  = q.front() ;
		q.pop();
		vis[u] = false ;
		for(int i = head[u] ; i != -1 ; i = e[i].next){
			int v = e[i].to;
			if(dist[v] > dist[u] + e[i].w){
				dist[v] = dist[u] + e[i].w;
				if(!vis[v]){
					vis[v] = true;
					q.push(v);
				}
			}
		}
	}
}
int main(){
	int a,b,c,s,e;
	cin >> n >> m;
	t = 0;
	memset(head,-1,sizeof(head));
	while(m--){
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);
	}
	cin >> s >> e;
	spfa(s);
	if(dist[e] == inf ) printf("-1\n");
	else printf("%d\n",dist[e]);
	return 0;
}