poj 1273 最大流基础

Drainage Ditches

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 28561		Accepted: 10432

Description

Every time it rains on Farmer John's fields, a pond forms over Bessie's favorite clover patch. This means that the clover is covered by water for awhile and takes quite a long time to regrow. Thus, Farmer John has built a set of drainage ditches so that Bessie's clover patch is never covered in water. Instead, the water is drained to a nearby stream. Being an ace engineer, Farmer John has also installed regulators at the beginning of each ditch, so he can control at what rate water flows into that ditch. 
Farmer John knows not only how many gallons of water each ditch can transport per minute but also the exact layout of the ditches, which feed out of the pond and into each other and stream in a potentially complex network. 
Given all this information, determine the maximum rate at which water can be transported out of the pond and into the stream. For any given ditch, water flows in only one direction, but there might be a way that water can flow in a circle. 

Input

The input includes several cases. For each case, the first line contains two space-separated integers, N (0 <= N <= 200) and M (2 <= M <= 200). N is the number of ditches that Farmer John has dug. M is the number of intersections points for those ditches. Intersection 1 is the pond. Intersection point M is the stream. Each of the following N lines contains three integers, Si, Ei, and Ci. Si and Ei (1 <= Si, Ei <= M) designate the intersections between which this ditch flows. Water will flow through this ditch from Si to Ei. Ci (0 <= Ci <= 10,000,000) is the maximum rate at which water will flow through the ditch.

Output

For each case, output a single integer, the maximum rate at which water may emptied from the pond.

Sample Input

5 4
1 2 40
1 4 20
2 4 20
2 3 30
3 4 10

Sample Output

50

Source

注：今天刚刚把最大流的基本问题搞明白，就练练这道题目，顺便简单介绍一下标号法求最大流的思想。

1.首先需要明白增广链的定义，这个可以查一下其他资料；

2.我们的目的是寻找每一条增广链，增大流量，直到所有的增广链都经过了扩大，即没有了增广链，这时得到的流肯定是最大流；

3.标号法是指对于每一个节点i，将与它相连的所有的未经过处理节点的p值赋为i以表示是有i找到的，如果是f[i,j]<c[i,j]即正向边不是饱和边，就将d:=min(d,c[i,j]-f[i,j])，如果是反向边并且属于非零流边，令d:=min(d,f[i,j])。

4.很明显3中的d是一个特殊的值，对于所有的正向边加上d反向边减去d不会影响这条路的可行流性质

5.一直执行2~3过程，直到不存在增广链。

上文讲的并不透彻，希望大家可以多看些课件，等我熟练后在写出更大众化的东西。

var 
  v:array[0..300] of boolean;
  p:array[0..300] of longint;
  f,c:array[0..300,0..300] of longint;
  i,j,k,m,n,ans,w:longint;

procedure findmax;
var
  i,j,d:longint;
begin
  while true do
    begin
      fillchar(v,sizeof(v),0);
      fillchar(p,sizeof(p),0);
      d:=maxlongint;
      repeat
        i:=0;
        p[1]:=maxlongint;
        repeat 
          inc(i);
        until (i>n)or((not v[i])and(p[i]<>0));
        if i>n then break;
        for j:=1 to n do if not v[j] then
          if p[j]=0 then
            begin
              if f[i,j]<c[i,j] then 
                begin
                  p[j]:=i;
                  if c[i,j]-f[i,j]<d then d:=c[i,j]-f[i,j];
                end else
              if f[j,i]>0 then
                begin
                  p[j]:=-i;
                  if f[j,i]<d then d:=f[j,i];
                end;
            end;
        v[i]:=true;
      until p[n]<>0;
      if p[n]=0 then break;
      i:=n;
      repeat 
        j:=i; i:=abs(p[j]);
        if p[j]<0 then dec(f[j,i],d) 
                  else inc(f[i,j],d); 
      until i=1;
    end;
end;

begin
  while not eof do 
    begin
      readln(m,n);
      ans:=0;
      fillchar(f,sizeof(f),0);
      fillchar(c,sizeof(c),$ff);
      for i:=1 to m do 
        begin
          readln(j,k,w);
          if c[j,k]=-1 then c[j,k]:=w else inc(c[j,k],w);
        end;
      findmax;
      for i:=1 to n do
        for j:=1 to n do
          if (v[i])and(not v[j]) then
            if c[i,j]>0 then inc(ans,c[i,j]);
      writeln(ans);
    end;
end.

这是刚刚实现的队列写的代码：

var 
  q:array[0..30000] of longint;
  f,c:array[0..200,0..200] of longint;
  p:array[0..200] of longint;
  v:array[0..200] of boolean;
  i,j,k,m,n,ans,w:longint;
  
procedure findmax;
var  
  head,tail,now:longint;
  i,j,d:longint;
begin
  while true do
    begin
      fillchar(q,sizeof(q),0);
      fillchar(p,sizeof(p),0);
      fillchar(v,sizeof(v),0);
      head:=1;  tail:=1; d:=maxlongint; 
      v[1]:=true;  p[1]:=maxlongint; q[1]:=1;
      while head<=tail do
        begin
          now:=q[head];
          for i:=1 to n do
            if not v[i] then 
              begin 
                if f[now,i]<c[now,i] then 
                   begin
                     if d>c[now,i]-f[now,i] then 
                       d:=c[now,i]-f[now,i];
                     p[i]:=now;
                     v[i]:=true; inc(tail); q[tail]:=i;
                   end else
                if f[i,now]>0 then
                   begin
                     if d>f[i,now] then d:=f[i,now];
                     p[i]:=-now;
                     v[i]:=true; inc(tail); q[tail]:=i;
                   end;
              end;
          inc(head);
        end;
      if not v[n] then break;
      i:=n;
      while i<>1 do
        begin
          j:=i; i:=abs(p[j]);
          if p[j]<0 then dec(f[j,i],d)
                    else inc(f[i,j],d);
        end;
    end;
    for i:=1 to tail do
      for j:=1 to n do
        if not v[j] then 
          inc(ans,c[q[i],j]);
end;

begin 
  assign(input,'ditch.in'); reset(input);
  assign(output,'ditch.out'); rewrite(output);
  readln(m,n);
  ans:=0;
  for i:=1 to m do
    begin
      readln(j,k,w);
      inc(c[j,k],w);
    end;
  findmax;
  writeln(ans);
  close(input); close(output);
end.