前向星+SPFA(转载)

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋    

 

代码

前向星 + SPFA
我是在做USACO的sweet butter时偶然发现这个东西的。。。
这个算法，简单的说就是队列优化的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，若小于则改进Dist，将Fa记为v，并且由于S到u的最短距离变小了，有可能u可以改进其它的点，所以若u不在队列中，就将它放入队尾。这样一直迭代下去直到队列变空，也就是S到所有的最短距离都确定下来，结束算法。
SPFA 在形式上和宽度优先搜索非常类似，不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列，但是SPFA中一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本身被改进，于是再次用来改进其它的点，这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k，有办法证明对于通常的情况，k在2左右
前向星优化：
不要把前向星想成什么高深莫测的东西……它其实就是一种邻接表的紧缩存储形式。
为什么叫前向星？因为它是将边按照前端点排序，并用一个数组k[i]记录端点i第一次以左端点出现的位置。这样，我们就能用O(E)的空间复杂度存储下一个邻接表，而避免了链表或N ^ 2的庞大空间消耗。
当然，实际上我们并不需要排序：因为我们只需要知道某一条边应该放到什么位置即可。因而我们还需要一个数组t[i]存储从i出发的边的条数。则需要存储在的位置就可以很轻易地求得。（详见代码）
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.

 

 

转载于:https://www.cnblogs.com/MiYu/archive/2010/10/23/1859513.html