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次则存在负环（SPFA无法处理带负环的图）

 

　　SPFA实际上是Bellman-Ford基础上的优化

　　SPFA(G,w,s)

　　1. INITIALIZE-SINGLE-SOURCE(G,s)

　　2. INITIALIZE-QUEUE(Q)

　　3. ENQUEUE(Q,s)

　　4. While Not EMPTY(Q)

　　5. Do u<-DLQUEUE(Q)

　　6. For 每条边(u,v) in E[G]

　　7. Do tmp<-d[v]

　　8. Relax(u,v,w)

　　9. If (d[v] < tmp) and (v不在Q中)

　　10. ENQUEUE(Q,v)

 

　　一种更容易读懂的伪代码

　　Procedure SPFA;

　　Begin

　　initialize-single-source(G,s);

　　initialize-queue(Q);

　　enqueue(Q,s);

　　while not empty(Q) do begin

　　u:=dequeue(Q);

　　for each v∈adj[u] do begin

　　tmp:=d[v];

　　relax(u,v);

　　if (tmp<>d[v]) and (not v in Q) then enqueue(Q,v);

　　end;

　　end;

　　End标准SPFA过程　　(以求某个结点t到某个结点s的最短路为例，稍加修改即为单源最短路)program spfaprg;

　　

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..maxp] of integer; {队列}

　　v:array[1..maxp] of boolean; {是否入队的标记}

　　dist:array[1..maxp] of longint; {到起点的最短路}

　　head,tail:longint; {队首/队尾指针}

　　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(d,sizeof(d),0);

　　fillchar(v,sizeof(v),false);

　　for j := 1 to p do dist[ j ]:=maxlongint;

　　dist[s] := 0; v[s] := true; d[1] := s; {队列的初始状态,s为起点}

　　head := 1; tail := 1;

　　while head<=tail do {队列不空}

　　begin

　　now := d[head]; {取队首元素}

　　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

　　inc(tail);

　　d[tail] := b[now,i];

　　v[b[now,i]] := true;

　　end;

　　end;

　　v[now] := false; {释放结点}

　　inc(head); {出队}

　　end;

　　end;

　　procedure print;

　　begin

　　writeln(dist[t]);

　　end;

　　begin

　　init;

　　spfa(s);

　　print;

　　end.

　　

C语言代码

#include<stdio.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));

　　memset(dist,127,sizeof(dist));//置dist数组为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]);

　　system("pause");

　　return 0;

　　};