hdu1532Drainage Ditches（Ford-Fulkerson）

Drainage Ditches

 

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 20940    Accepted Submission(s): 10056

 

 

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

题意：每次下雨时，农夫约翰最喜爱的苜（一种草本植物）就会被水覆盖，需要相当长的时间才能再生。 因此，农夫已经建立了一组排水沟，以便苜不会被水覆盖。 水被排放到附近的小溪。农夫约翰在每条沟的开始都安装了调节器，因此他可以控制水流入该沟的速率。农夫约翰不仅知道每个沟渠每分钟可以运输多少加仑水，而且还知道沟渠的确切布局，这些沟渠从池塘中流出，流入彼此，流入一个的复杂网络。

思路：实质上就是最大流问题，利用Ford-Fulkerson算法可以解决，通过DFS不断寻找增广路，直到残余网络上不存在一条增广路为止。

AC代码：

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;
const int INF =0x3f3f3f3f;
const int MAXN =200+10;

struct edge{
    int to;//终点
    int cap;//容量
    int rev;//反向边
};
vector<edge> G[MAXN];
bool used[MAXN];
void add_edge(int from ,int to,int cap){
   G[from].push_back((edge){to,cap,G[to].size()});
   G[to].push_back((edge){from,0,G[from].size()-1});
}
int dfs(int v,int t,int f){
    if(v==t)
        return f;
    used[v]=true;
    for(int i=0;i<G[v].size();i++){
        edge &e=G[v][i];
        if(!used[e.to]&&e.cap>0){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t){
    int flow=0;
    for(;;){
        memset(used,false,sizeof(used));
        int f=dfs(s,t,INF);
        if(f==0)
            return flow;
        flow+=f;
    }
}
int main(){
    int n,m,a,b,c;
    while(~scanf("%d%d",&n,&m)){
        memset(G,0,sizeof(G));
        for(int i=0;i<n;i++){
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
		}
        int ans=max_flow(1,m);
        printf("%d\n",ans);
    }
}