登山者的仰望

松弛操作

单源最短路径算法中使用了松弛（relaxation）操作。对于每个顶点v∈V，都设置一个属性d[v]，用来描述从源点s到v的最短路径上权值的上界，称为最短路径估计（shortest-path estimate）。π[v]代表S到v的当前最短路径中v点之前的一个点的编号,我们用下面的Θ(V)时间的过程来对最短路径估计和前趋进行初始化。

 CodeIALIZE-SINGLE-SOURCE(G,s)
1   for each vertex v∈V[G]
2      do d[v]←∞
3         π[v]←NIL
4   d[s]←0

 经过初始化以后，对所有v∈V，π[v]=NIL，对v∈V-{s}，有d[s]=0以及d[v]=∞。

在松弛一条边(u,v)的过程中，要测试是否可以通过u，对迄今找到的v的最短路径进行改进；如果可以改进的话，则更新d[v]和π[v]。一次松 弛操作可以减小最短路径估计的值d[v]，并更新v的前趋域π[v](S到v的当前最短路径中v点之前的一个点的编号)。下面的伪代码对边(u,v)进行 了一步松弛操作。

Code
RELAX(u, v, w)
1   if(d[v]>d[u]+w(u,v))
2      then d[v]←d[u]+w(u,v)
3           π[v]←u

 每个单源最短路径算法中都会调用INITIALIZE-SINGLE-SOURCE，然后重复对边进行松弛的过程。另外，松弛是改变最短路径和前趋的唯一 方式。各个单源最短路径算法间区别在于对每条边进行松弛操作的次数，以及对边执行松弛操作的次序有所不同。在Dijkstra算法以及关于有向无回路图的 最短路径算法中，对每条边执行一次松弛操作。在Bellman-Ford算法中，每条边要执行多次松弛操作。

SPFA算法

SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。

算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。

Code
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(v);
         end;
      end;
End;

Code
procedure spfa;
begin
fillchar(q,sizeof(q),0); h:=0; t:=0;//队列
fillchar(v,sizeof(v),false);//v[i]判断i是否在队列中
for i:=1 to n do dist[i]:=maxint;//初始化最小值
 
inc(t); q[t]:=1; v[1]:=true;
dist[1]:=0;//这里把1作为源点
 
while not(h=t) do
begin
    h:=(h+1)mod n;x:=q[h];  v[x]:=false;
    for i:=1 to n do
     if (cost[x,i]>0)and(dist[x]+cost[x,i]<dist[i]) then
     begin
       dist[i]:=dist[x]+cost[x,i];
       if not(v[i]) then
       begin
         t:=(t+1)mod n; q[t]:=i;v[i]:=true;
       end;
     end;
end;
end;

bellman-ford(贝尔曼-福特)算法

Bellman-Ford算法(根据发明者 Richard Bellman 和 Lester Ford 命名)是求解单源最短路径问题的一种算法。单源点的最短路径问题是指：给定一个加权有向图G和源点s，对于图G中的任意一点v，求从s到v的最短路径。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore zu 也为这个算法的发展做出了贡献。

与迪科斯彻算法， （另一种著名的求最短路径的算法）不同的是，在Bellman-Ford算法中，路径的权值可以为负数。 设想从我们可以从图中找到一个环路（即从v出发，经过若干个点之后又回到v）且这个环路中所有路径的权值之和为负。那么通过这个环路，环路中任意两点的最 短路径就可以无穷小下去。如果不处理这个负环路，程序就会永远运行下去。 而Bellman-Ford算法具有分辨这种负环路的能力。

算法描述 设G为加权有向图 V是所有结点的集合 E是所有路径的集合 S表示源点 n表示V中所有结点的数目 weight(u,v)表示从结点u到结点v的路径的权值。 Distanz（v）表示从源点s出发到结点v的最短路径的距离，（或者说是从s到v所有的路径中权值的最小值）。Predecessor(v)表示节点 v的父结点

在Bellman-Ford算法结束之后，可以输出，G是不是包含一个负环路。如果G不包含负环路，那么Distanz就存储了从s出发到所有结点的距离。

Bellman-Ford算法的伪代码如下：

Code
01 for 每一个结点v 属于 V
02 Distanz(v) := 无穷大， Predecessor(v) := null
03 Distanz(s) := 0，Predecessor(s):= null;
 
04 循环 n-1 次
05     for 每一条路径 （u,v）属于 E
06         if Distanz(u) + weight(u,v) < Distanz(v) 
07         then
08            Distanz(v) := Distanz(u) + weight(u,v)
09            Predecessor(v) := u;

10 for 每一条路径 （u，v）属于 E
11     if Distanz(u) + weight(u,v) < Distanz(v) 
12     then
13       中止程序并且返回 “找到负循环”
14 返回

Code
BF(G,w,s) // G = Graph, w = weight, s=source
Determine Single Source(G,s);
set Distance(s) = 0; Predecessor(s) = nil;
for each vertex v in G other than s, 
   set Distance(v) = infinity, Predecessor(v) = nil;
for i <- 1 to |V(G)| - 1 do   //|V(G)| Number of vertices in the graph
   for each edge (u,v) in G do
      if Distance(v) > Distance(u) + w(u,v) then
         set Distance(v) = Distance(u) + w(u,v), Predecessor(v) = u;  
for each edge (u,r) in G do
   if Distance(r) > Distance(u) + w(u,r);
      return false; //This means that the graph contains a cycle of negative weight 
                    //and the shortest paths are not well defined
return true; //Lengths of shortest paths are in Distance array

 例：V={v1,v2,v3,v4} E={(v1,v2),(v1,v3),(v2,v4),(v4,v3)} weight(v1,v2)=-1 weight(v1,v3)=3 weight(v2,v4)=3 weight(v4,v3)=-1

运行如表： D:Distanz(v)，P:Predecessor(v)