对于不含负权边的图求单源最短路径，Dijkstra算法是最高效的。但是在含负权边的图中，Dijkstra很可能得不到正确的结果，因为Dijkstra每次选的是当前能连到的边中权值最小的，在正权图中这种贪心是对的，但是在负权图中就不是这样了。比如1–>2权值为5，1–>3权值为6，3–>2权值为-2，求1到2的最短路径时，Dijkstra就会选择权为5的1–>2，但实际上1–>3–>2才是最优的结果。

Bellman-Ford与SPFA都是解决这一问题的算法，两者的程序都很简单清晰【其实后者就是前者的一个优化】，所以也比较容易掌握。

一、Bellman-Ford算法

说到Bellman-Ford一定会说到松弛（relaxation）技术，即用d[i]来预计s到i的最短距离。在计算过程中不断地缩小d[i]，直到最后d[i]就是源点s到i的最短距离。至于为什么叫“松弛”，尽管算法导论中给出了一段说明，但我们只需认为这是作者在故弄玄虚即可，松弛就是求单源最短路径的迭代过程，d[i]也可以看为存储当前s到i的最短距离。

算法核心代码如下：（针对有向图，Pascal语言）

棕色部分：

    n为图顶点数，m为图边数。

    Cost[i,j]表示边（i，j）的权

    Edge存放图的所有边

    D即上文所述的用于存储当前s到i的最短距离的数组

    Closest[i]记录s到i的最短路径上i的前趋。最后要求i到s的路径时，只需用递归打印Closest[i]、Closest[Closest[i]]、Closest[Closest[Closest[i]]、…、s便可求出整条路径。

绿色部分： 算法的初始化。

        对于不为s的所有i∈V，d[i]初始赋为一个足够大的数来表示无限大【之所以不使用maxlongint而是使用100000000是因为下面要有无限大与实数相加的操作，如果maxlongint就会溢出（201错误）】，closest[i]赋为-1表示nil。d[s]赋为0表示s到s的距离为0。

红色部分： 算法的迭代求解部分。

        程序很好理解，就是不断枚举每条边，更新当前找到的最短路径。对于不含负权回路的图，循环n-1次一定能对任意i使d[i]为s到i的最短路径，因为这段过程相当于枚举了s到其他所有点的所有路径。

蓝色部分： 算法的检验部分。

        上面已经提到，如果是不含负权回路的图，d[i]一定是最短路径，不存在还需要更新的可能性，所以不会执行到exit(false)；至于当exit(false)时一定是存在负权回路的原因，算法导论上有一个比较复杂的证明，但是抛弃严谨的证明的话，理解起来却很容易：当图不含负权回路时一定不会exit(false)，逆否命题为当exit（false）时一定含负权回路。原命题成立，因此逆否命题一定成立。

从流程可以看出，Bellman-Ford的时间复杂度为O(EV)，对于E接近V^2的稠密图为O(V^3)，对于E接近V的稀疏图为O（V^2）。

当然，我们可以看到Bellman-Ford做了很多不必要的判断。如果i还没有循环到n-1但已经计算出最小路径时，d边不会再更新，但是循环却还要做到n-1，接下去的运算全部都是没有用的运算。所以我们在循环中加一个布尔型变量flag，进入外循环时flag设为false，若d有变化则flag改为true。在内循环全部做完后若flag还是false则说明算法已经完毕，直接退出算法并返回true。改进后的算法如下：

紫色部分为加入的语句。

这样虽然时间复杂度仍为O（VE），但是效率显然会有所提高。

二、SPFA算法

前面已经说到，Bellman-Ford存在大量的废运算，即使优化过仍是这样。SPFA作为Bellman-Ford的一个改进，尽可能地减少了废运算，从而提高了效率。

Bellman-Ford是枚举每条路径从而算出结果的，也就是一个点是否需要松弛依赖于其连接的点。SPFA的思想是用一个队列存放所有需要松弛的点，初始时队列中只有源点s，进行计算时，若队列为空则算法结束，否则将队首顶点取出后对其相邻的点基于取出地点进行松弛。如果某邻点松弛成功（改变了d中对应的值）并且那个点不在队列中，则将其入队。在进行以上操作时需要记录每个点进入队列的次数。如果有点进入队列超过|V|次则说明图存在负权回路，退出算法并返回false。

算法核心代码如下：（针对有向图，Pascal语言）

function spfa(s:longint):boolean;

var i,j,k,l,r:longint;

    q:array[1..maxn*maxn] of longint;

    f:array[1..maxn] of boolean;

    t:array[1..maxn] of longint;

begin

l:=1;r:=1;q[1]:=s;fillchar(f,sizeof(f),false);f[s]:=true;

fillchar(t,sizeof(t),0);t[s]:=1;

for i:=1 to n do begin

    d[i]:=100000000;

    closest[i]:=-1;

end;

d[s]:=0;

while l<=r do begin

    i:=q[l];inc(l);

    for j:=1 to edge[i,0] do begin

      k:=edge[i,j];

      if (d[k]>d[i]+cost[i,k]) then begin

          d[k]:=d[i]+cost[i,k];

          closest[k]:=i;

          if not f[k] then begin

            f[k]:=true;

            inc(t[k]);

            if t[k]>n then exit(false);

            inc(r);

            q[r]:=k;

          end;

        end;

      end;

    f[i]:=false;

end;

exit(true);

end;

为了方便计算连到某个点的所有边，此处的edge数组用二维数组表示，edge[i,0]表示i的度（连到i的边数），edge[i,1..edge[i,0]]分别存放每一条边另一端的顶点。

这里的队列p长度n^2可能比较危险。事实上队列中元素的上限为n，完全可以滚动数组来把p的长度压为n，但是这样程序理解和实现起来可能会比较困难，所以入门时这样就行了。

SPFA的复杂度很难计算，一般公认为O（kE），k为常数。

三、Bellman-Ford、SPFA、朴素Dijkstra效率实测

评测环境：WindowsXP，FreePascal2.40，Pentium（R） Dual-Core CPU T4300@2.10GHz，2G内存

   可以看出，SPFA是优于优化后的Bellman-Ford的，所以尽可能地用SPFA吧，记得滚动那个队列数组– –

    关于Dijkstra，测试的那个程序是朴素的，也就是不含堆优化的。如果加了二叉堆优化是肯定会优于SPFA的。至于怎么优化请参看前一篇里Prim的优化，实质上是一样的……

附：SPFA的两个优化

转自http://www.artofproblemsolving.com/Forum/weblog_entry.php?t=257702，作者zkw

    SPFA与堆优化的Dijkstra的速度之争不是一天两天了，不过从这次USACO月赛题来看，SPFA用在分层图上会比较慢。标程是堆优化的Dijkstra，我写了一个非常朴素的SPFA，只能过6/11个点。SPFA是按照FIFO的原则更新距离的，没有考虑到距离标号的作用。实现中 SPFA 有两个非常著名的优化：SLF 和 LLL。

　　SLF：Small Label First 策略。
　　实现方法是，设队首元素为 ，队列中要加入节点 ，在 时加到队首而不是队尾，否则和普通的 SPFA 一样加到队尾。

　　LLL：Large Label Last 策略。
　　实现方法是，设队列 中的队首元素为 ，距离标号的平均值为 ，每次出队时，若 ，把 移到队列末尾，如此反复，直到找到一个 使 ，将其出队。

　　加上SLF优化后程序多了一行，过了9/11个点。你问我怎么用SPFA AC这个题？利用分层图性质，算完一层再算一层，对每一层计算用SPFA，加上上面的优化，程序飞快：最强的优化要利用题目的特殊性质。