SPFA算法及前向星优化

先说说spfa算法：

SPFA算法

来自"NOCOW"

算法简介

SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。也有人说SPFA本来就是Bellman-Ford算法，现在广为流传的Bellman-Ford算法实际上是山寨版。

算法流程

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

这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法

SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：

设Dist代表S到I点的当前最短距离，Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。

维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。

每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。若一个点入队次数超过n，则有负权环。

SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右 

 

 

接下来是前向星：

 前向星优化：
不要把前向星想成什么高深莫测的东西……它其实就是一种邻接表的紧缩存储形式。
为什么叫前向星？因为它是将边按照前端点排序，并用一个数组k[i]记录端点i第一次以左端点出现的位置。这样，我们就能用O(E)的空间复杂度存储下一个邻接表，而避免了链表或N^2的庞大空间消耗。
当然，实际上我们并不需要排序：因为我们只需要知道某一条边应该放到什么位置即可。因而我们还需要一个数组t[i]存储从i出发的边的条数。则需要存储在的位置就可以很轻易地求得。（详见代码，以USACO中的butter为例）
Butter题目代码如下：Program butter(input,output);
Type
   edge=record
            x,y,d:longint;
        end;
Var
   min,res,n,p,c,x,y,i,j,l,r:longint;
   te,e:array[0..3000] of edge;
   tk,t,k,num,d:array[1..800] of longint;
   q:array[1..100000] of longint;
   use:array[1..800] of boolean;
Procedure swap(var n1,n2:longint);
Var
   tmp:longint;
Begin
   tmp:=n1;n1:=n2;n2:=tmp;
End;
Begin
   assign(input,'butter.in');reset(input);
   readln(n,p,c);
   for i:=1 to n do
   begin
      read(x);
      inc(num[x]);
   end;
   for i:=1 to c do
   begin
      with e[i*2-1] do readln(x,y,d);
      e[i*2]:=e[i*2-1];
      swap(e[i*2].x,e[i*2].y);
   end;
   c:=c*2;
   for i:=1 to c do inc(t[e[i].x]);
   j:=0;k[1]:=1;
   for i:=2 to p do
      k[i]:=k[i-1]+t[i-1];
   tk:=k;te:=e;
   for i:=1 to c do
   begin
      e[tk[te[i].x]]:=te[i];
      inc(tk[te[i].x]);
   end;
   min:=maxlongint;
   for i:=1 to p do
   begin
      fillchar(q,sizeof(q),0);
      fillchar(d,sizeof(d),127);
      fillchar(use,sizeof(use),false);
      q[1]:=i;l:=1;r:=1;d[i]:=0;use[i]:=true;
      repeat
            for j:=k[q[l]] to k[q[l]]+t[q[l]]-1 do
               if d[q[l]]+e[j].d<d[e[j].y] then
               begin
                  d[e[j].y]:=d[q[l]]+e[j].d;
                  if not use[e[j].y] then
                  begin
                     use[e[j].y]:=true;
                     inc(r);
                     q[r]:=e[j].y;
                  end;
               end;
            use[q[l]]:=false;
            inc(l);
      until l>r;
      res:=0;
      for j:=1 to p do
         res:=res+d[j]*num[j];
      if res<min then min:=res;
   end;
   assign(output,'butter.out');rewrite(output);
   writeln(min);close(output);
End.