算法模板——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[..] of point;
    d,dv:array[..] 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:=;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:=;p:=a[x];
               while p<>nil do
                     begin
                          if (p^.w>) and (d[x]=(d[p^.g]+)) 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]]= then d[s]:=n;
               inc(d[x]);inc(dv[d[x]]);
          end;
 begin
      readln(n,m,s,t);
      for i:= to n do a[i]:=nil;
      for i:= to m do
          begin
               readln(j,k,l);
               add(j,k,l);
          end;
      fillchar(d,sizeof(d),);
      fillchar(dv,sizeof(dv),);
      dv[]:=n;ans:=;
      while d[s]<n do inc(ans,dfs(s,maxlongint));
      writeln(ans);
 end.