算法模板——sap网络最大流 3（递归+邻接表）

实现功能：同前

程序还是一如既往的优美，虽然比起邻接矩阵的稍稍长了那么些，不过没关系这是必然，但更重要的一个必然是——速度将是一个质的飞跃^_^(这里面的point指针稍作了些创新——anti指针，这个指向当前弧的反向弧，便于路径增广时的操作，相比非递归里面非要用一个op函数来挨个找已经强多了！！！)

type
    point=^node;
    node=record
               g,w:longint;
               anti,next:point;
    end;
var
   i,j,k,l,m,n,ans,s,t:longint;
   a:array[0..10000] of point;
   d,dv:array[0..10000] of longint;
function min(x,y:longint):longint;inline;
         begin
              if x<y then min:=x else min:=y;
         end;
procedure add(x,y,z:longint);inline;
          var p:point;
          begin
               new(p);p^.g:=y;p^.w:=z;p^.next:=a[x];a[x]:=p;
               new(p);p^.g:=x;p^.w:=0;p^.next:=a[y];a[y]:=p;
               a[y]^.anti:=a[x];a[x]^.anti:=a[y];
          end;
function dfs(x,flow:longint):longint;inline;
         var i,j,k,l:longint;p:point;
         begin
              if x=t then exit(flow);
              dfs:=0;p:=a[x];
              while p<>nil do
                    begin
                         if (p^.w>0) and (d[x]=(d[p^.g]+1)) then
                            begin
                                 k:=dfs(p^.g,min(flow-dfs,p^.w));
                                 dec(p^.w,k);
                                 inc(p^.anti^.w,k);
                                 inc(dfs,k);
                                 if dfs=flow then exit;
                            end;
                         p:=p^.next;
                    end;
              if d[s]=n then exit;
              dec(dv[d[x]]);
              if dv[d[x]]=0 then d[s]:=n;
              inc(d[x]);inc(dv[d[x]]);
         end;
begin
     readln(n,m,s,t);
     for i:=1 to n do a[i]:=nil;
     for i:=1 to m do
         begin
              readln(j,k,l);
              add(j,k,l);
         end;
     fillchar(d,sizeof(d),0);
     fillchar(dv,sizeof(dv),0);
     dv[0]:=n;ans:=0;
     while d[s]<n do inc(ans,dfs(s,maxlongint));
     writeln(ans);
end.