标题：SPFA
SPFA算法
简介求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm。
SPFA算法是西南交通大学段凡丁于1994年发表的.
从名字我们就可以看出，这种算法在效率上一定有过人之处。
很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。
简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。
我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是松弛：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。原理定理： 只要最短路径存在，上述SPFA算法必定能求出最小值。
证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。（证毕） 
期望的时间复杂度O(ke）， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。
实现方法：建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空
判断有无负环：如果某个点进入队列的次数超过N次则存在负环 (存在负环则无最短路径，如果有负环则会无限松弛，而一个带n个点的图至多松弛n-1次）
伪代码
SPFA实际上是Bellman-Ford基础上的优化
（这里的q数组表示的是节点是否在队列中，如q[v]=1则点v在队列中）
SPFA(G,w,s）　 
⒈ INITIALIZE-SINGLE-SOURCE(G,s)
⒉ Q ← &Oslash;
⒊ for each vertex ∈ V[G]
⒋ q[v]=0
⒌ ENQUEUE(Q,s)
⒍ q[s]=1
⒎ while Q≠&Oslash;
⒏ dou ← DEQUEUE(Q)
⒐ q[u]=0
⒑for each edge(u,v) ∈ E[G]
⒒ dot ← d[v]
⒓ RELAX(u,v,w)
⒔ π[v] ← u
⒕ if(d[v] < t) and 
⒖ ENQUEUE(Q,v)
⒗ q[v]=1
一种更容易读懂的伪代码
pascal
Procedure SPFA;
Begin
initialize-single-source(G,s); // 初始化单源
initialize-queue(Q); //初始化队列
enqueue(Q,s); //插入s到队列Q
while not empty(Q) do begin //如果Q不为空
u:=dequeue(Q); //取Q开头的元素
for each v∈adj[u] do begin //枚举adj[u]的所有节点
tmp:=d[v];
relax(u,v);
if (tmp<>d[v]) and (not v in Q) then enqueue(Q,v); //插入v
end;
end;
End;
c++
void spfa() {
初始化（G,s);
初始化队列Q;
插入s到队列Q;
while（！空（Q)) {
u=Q的开头元素，并删除；
for each v in adj[u] {
tmp = d[v];
relax(u,v);
if((tmp<>d[v])&&(!v in Q)) 插入v到队列Q;
}
}
}
期望的时间复杂度O（2e) 
对spfa的一个很直观的理解就是由无权图的bfs转化而来.在无权图中，bfs首先到达的顶点所经历的路径一定是最短路（也就是经过的最少顶点数）.所以此时利用visit[u]，可以使每个顶点只进队一次.在带权图中，最先到达的顶点所计算出来的路径不一定是最短路.一个解决方法是放弃visit数组，此时所需时间自然就是指数级的.所以我们不能放弃visit数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解.
标准SPFA过程
（以求某个结点t到某个结点s的最短路为例，稍加修改即为单源最短路）Pascal语言代码const
maxp=10000; {最大结点数}
var {变量定义}
p,c,s,t:longint; {p，结点数；c，边数；s：起点；t：终点}
a,b:array[1..maxp,0..maxp] of longint; {a[x,y]存x,y之间边的权；b[x,c]存与x相连的第c个边的另一个结点y}
d:array[1..2*maxp] of integer; {队列}
v:array[1..maxp] of boolean; {是否入队的标记}
dist:array[1..maxp] of longint; {到起点的最短路}
head,tail,h1,t1:longint; {队首/队尾指针，h1、t1用于判断队空为防止出现循环队列中尾指针饶了一圈绕到头指针前面的情况}
procedure init;
var i,x,y,z:longint;
begin
read(p,c);
for i := 1 to c do
begin
readln(x,y,z); {x,y：一条边的两个结点；z：这条边的权值}
inc(b[x,0]); b[x,b[x,0]] := y; a[x,y] := z; {b[x,0]：以x为一个结点的边的条数}
inc(b[y,0]); b[y,b[y,0]] := x; a[y,x] := z;{若为有向图，此句删去.（不删去无法处理负边）}
end;
readln(s,t); {读入起点与终点}
end;
procedure spfa(s:longint); {SPFA}
var i,j,now,sum:longint;
begin
fillchar(v,sizeof(v),false);
for j := 1 to p do dist[j]:=maxlongint;
dist[s]:=0; v[s]:=true;now:=s;{队列的初始状态，s为起点}
head:=0;tail:= 0;h1:=0;t1:=0;
d[head]:=s;
while h1<=t1 do {队列不空}
begin
now:=d[head mod maxp]; {取队首元素}
for i:=1 to b[now,0] do
if dist[b[now,i]]>dist[now]+a[now,b[now,i]] then
begin
dist[b[now,i]]:= dist[now]+a[now,b[now,i]]; {修改最短路}
if not v[b[now,i]] then {扩展结点入队}
begin
tail:=(tail+1）mod maxp;t1:=t1+1;
d[tail] := b[now,i];
v[b[now,i]] := true;
end;
end;
v[now] := false; {释放结点}
head:=(head+1）mod maxp;h1:=h1+1;{出队}
end;
end;
procedure print;
begin
writeln(dist[t]);
end;
begin
init;
spfa(s);
print;
end.C语言代码#include<stdio.h>
#include<string.h>
#define maxint 2139062143
int a[101][101],dist[101],n;
void spfa(int s)
{
int q[101],v[101],h=0,t=1,x,i;//q为队列，v为Boolean数组，表示结点是否在队列中，h为头指针，t为尾指针
memset(q,0,sizeof(q));
memset(v,0,sizeof(v));
for(i=0;i<101;i++)//这里应该用for循环初始化，memset函数只能将值初始化为0或者-1。
dist[i] = maxint;
dist[s]=0;
q[t]=s;v[s]=1;
while(h!=t)//本来是h<t,但这不是循环队列么，不能这么干的...
{
h=(h+1)%(n+1);//这里不能%n否则队满和队空状态一样
x=q[h];
v[x]=0;
for(i=1;i<=n;i++)
if(dist[i]-a[x][i]>dist[x])//这里本来为dist[i]>dist[x]+a[x][i]，但这样会越界的，因为后两者加起来太大
{
dist[i]=dist[x]+a[x][i];
if(!v[i])
{
t=(t+1)%(n+1);//同上
q[t]=i;v[i]=1;
}
}
}
}
int main()
{
int m,s,t,i;
scanf("%d%d",&n,&m);
scanf("%d%d",&s,&t);
memset(a,127,sizeof(a));
for(i=1;i<=m;i++)
{
int x,y,z;
scanf("%d%d%d",&x,&y,&z);
a[x][y]=z;
a[y][x]=z;
}
spfa(s);
printf("%d",dist[t]);
return 0;
}
优化
SPFA最常用的优化是SLF优化，即将队列用双端队列实现。如果该点源点S到当前节点I的距离小于队列首的节点距离，那么就把该节点放入队列首，否则放入队列尾。
实现
最基本的前向星优化的spfa（有向图）复杂度O(ke).
var
a,b,e:array[1..1000] of longint;
vis:array[1..2000] of boolean;
q,d,f:array[1..2001] of longint;
n,m,i,s,t:longint;
procedure qsort(l,r:longint);
var i,j,x,y:longint;
begin
i:=l;
j:=r;
x:=a[(l+r) shr 1];
repeat
while a[i]<x do inc(i);
while a[j]>x do dec(j);
if not(i>j) then begin
y:=a[i]; a[i]:=a[j]; a[j]:=y;
y:=b[i]; b[i]:=b[j]; b[j]:=y;
y:=e[i]; e[i]:=e[j]; e[j]:=y;
inc(i);
dec(j);
end;
until i>j;
if i<r then qsort(i,r);
if l<j then qsort(l,j);
end;
procedure spfa(s:longint);
var i,k,l,t:longint;
begin
fillchar(vis,sizeof(vis),false);
for i:=1 to n do d[i]:=maxlongint;
d[s]:=0;
l:=0;
t:=1;
q[1]:=s;
vis[s]:=true;
repeat
l:=l mod 10000 +1;
k:=q[l];
for i:=f[k] to f[k+1]-1 do
if d[k]+e[i]<d[b[i]] then
begin
d[b[i]]:=d[k]+e[i];
if not vis[b[i]] then begin
t:=t mod 10000 +1;
q[t]:=b[i];
vis[b[i]]:=true;
end;
end;
vis[k]:=false;
until l=t;
end;
Begin
readln(n,m);
for i:=1 to m do
readln(a[i],b[i],e[i]);
qsort（1,m);
for i:=1 to m do
if f[a[i]]=0 then f[a[i]]:=i;
f[n+1]:=m+1;
for i:=n downto 1 do
if f[i]=0 then f[i]:=f[i+1];
readln(s,t);
spfa(s);
writeln(d[t]);
end.堆排实现（无向图）const MM=1000;
var
a,b,e:array[1..MM] of longint;
q,d,f:array[1..2*MM+1] of longint;
vis:array[1..MM] of boolean;
n,m,i,s,t:longint;
mh:longint;
procedure heapify(i:longint);
var l,r,max,temp:longint;
begin
l:=2*i;
r:=l+1;
max:=i;
if (l<=mh) and (a[l]>a[max]) then max:=l;
if (r<=mh) and (a[r]>a[max]) then max:=r;
if max<>i then begin
temp:=a[i]; a[i]:=a[max]; a[max]:=temp;
temp:=b[i]; b[i]:=b[max]; b[max]:=temp;
temp:=e[i]; e[i]:=e[max]; e[max]:=temp;
heapify(max);
end;
end;
procedure heap;
var i,temp:longint;
begin
mh:=m;
for i:=(m div 2） downto 1 do heapify(i);
for i:=m downto 2 do begin
temp:=a[i]; a[i]:=a[1]; a[1]:=temp;
temp:=b[i]; b[i]:=b[1]; b[1]:=temp;
temp:=e[i]; e[i]:=e[1]; e[1]:=temp;
dec(mh);
heapify⑴；
end;
end;
procedure spfa(s:longint);
var i,k,l,t:longint;
begin
fillchar(vis,sizeof(vis),false);
for i:=1 to n do d[i]:=maxlongint;
d[s]:=0;
l:=0;
t:=1;
vis[s]:=true;
q[1]:=s;
repeat
l:=(l mod （2*MM)) +1;
k:=q[l];
for i:=f[k] to f[k+1]-1 do
if d[k]+e[i]<d[b[i]] then
begin
d[b[i]]:=d[k]+e[i];
if not vis[b[i]] then begin
t:=(t mod （2*MM)) +1;
q[t]:=b[i];
vis[b[i]]:=true;
end;
end;
vis[k]:=false;
until l=t;
end;
Begin
readln(n,m);
for i:=1 to m do begin
readln(a[i],b[i],e[i]);
a[i+m]:=b[i];
b[i+m]:=a[i];
e[i+m]:=e[i];
end;
m:=m+m;
heap;
for i:=1 to m do if f[a[i]]=0 then f[a[i]]:=i;
f[n+1]:=m+1;
for i:=n downto 1 do if f[i]=0 then f[i]:=f[i+1];
readln(s,t);
spfa(s);
writeln(d[t]);
end.邻接矩阵（无向图）以上两种是边集数组储存方式，以下是邻接矩阵（无向图）：
const MM=100*2;
var
n,m,i,j:longint;
g:array[1..MM,1..MM] of longint;
q,d:array[1..MM] of longint;
vis:array[1..MM] of boolean;
a,b,e,s,t:longint;
procedure spfa(s:longint);
var l,t,i,k:longint;
begin
fillchar(vis,sizeof(vis),false);
for i:=1 to n do d[i]:=maxlongint;
d[s]:=0;
l:=0;
t:=1;
q[1]:=s;
vis[s]:=true;
repeat
l:=l mod MM +1;
k:=q[l];
for i:=1 to n do
if (g[k,i]<maxlongint)and(d[k]+g[k,i]<d[i]) then begin
d[i]:=d[k]+g[k,i];
if not vis[i] then begin
t:=t mod MM +1;
q[t]:=i;
vis[i]:=true;
end;
end;
vis[k]:=false;
until l=t;
end;
begin
readln(n,m);
for i:=1 to n do
for j:=1 to n do g[i,j]:=maxlongint;
for i:=1 to m do
begin
readln(a,b,e);
g[a,b]:=e;
g[b,a]:=e;
end;
readln(s,t);
spfa(s);
writeln(d[t]);
end.