HDU 1532 Drainage Ditches （最大流）

Drainage Ditches

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 15617    Accepted Submission(s): 7436

Problem 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

USACO 93

题意：一个农夫他家的农田每次下雨都会被淹，所以这个农夫就修建了排水系统，还聪明的给每个排水管道设置了最大流量；首先输入两个数n , m ; n为排水管道的数量，m为节点的数量，接下来就是n行数，每一行分为x1 ， x2 ， x3 ；x1 , x2为节点的序号，x3为流量；然后问从1号节点到m号节点的最大流是多少？(懒得翻译总结，网上找的）

思路：非常裸的最大流模板题，照着模板敲的时候还机智的改了抄下来的模板中的一个错误（也不知道抄的时候在想什么），唯一需要注意的就是会有重边所以建邻接矩阵的时候需要 flow[a][b]+=c，而不是 flow[a][b]=c。

#include <iostream>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <queue>
using namespace std;
int flow[205][205];
int mark[205],pre[205];
long long f;
int n,m;
#define INF 0xfffffff

void max_flow(){
    while(1){
        memset(mark,0,sizeof(mark));
        memset(pre,0,sizeof(pre));
        queue<int> q;
        mark[1]=1;
        q.push(1);
        while(!q.empty()){
            int cnt = q.front();
            q.pop();
            if(cnt==n){
                break;
                }
            for(int i=1;i<=n;i++) {
                if(!mark[i]&&flow[cnt][i]>0){
                    mark[i]=1;
                    q.push(i);
                    pre[i]=cnt;
                }
            }
        }
        if(!mark[n])
            break;
        int minx=INF;
        for(int i=n; i!=1;i=pre[i]){
            minx=min(flow[pre[i]][i],minx);
        }
        for(int i=n;i!=1;i=pre[i]){
            flow[pre[i]][i]-=minx; 
            flow[i][pre[i]]+=minx; 
        }
        f+=minx;
    }
}

int main(){
    
    while(scanf("%d %d",&m,&n)!=EOF){
        memset(flow, 0, sizeof(flow));
        while(m--){
            int a,b,c;
            scanf("%d %d %d",&a,&b,&c);
            flow[a][b]+=c;
        }
        f=0;
        max_flow();
        printf("%d\n",f);
    }
    return 0;
}