HDU 1532 Drainage Ditches (最大网络流)

Drainage Ditches

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

Total Submission(s): 896 Accepted Submission(s): 414



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

解题：

最大网络流的模板题，从网上找了一个不错的模板，而有待理解。

#include <iostream>
using namespace std;
#define MAXN 205
#define INF 2110000000
#define MIN(x,y) (x<y?x:y)
int map[MAXN][MAXN];
int max_flow(int num,int map[][MAXN],int source,int sink)//参数含义：结点数量 网络 源点 汇点
{
	int my_queue[MAXN],queue_first,queue_end;//数组做队列 实现BFS搜索路径 
	int pre[MAXN],min_flow[MAXN];//记录结点的父节点 当前路径中最小的一段的值，也即限制值
	int flow[MAXN][MAXN];//记录当前网络中的流
	int ans=0;//最终结果
	memset(flow,0,sizeof(flow));
	while(1)//一直循环，直到不存在增广路径
	{
		queue_first=0;//初始化队列
		queue_end=0;
		my_queue[queue_end++]=source;
		memset(pre,-1,sizeof(pre));
		min_flow[source]=INF;
		pre[source]=-2;//源点的父节点需特殊标示
		while(queue_first<queue_end)//BFS寻找增广路径
		{
			int temp=my_queue[queue_first++];//出队列
			for(int i=0;i<num;i++)//由结点temp往外扩展
			{
				if(pre[i]==-1&&flow[temp][i]<map[temp][i])//当结点i还未被探索到，并且还有可用流量
				{	
					my_queue[queue_end++]=i;//加入队列
					pre[i]=temp;//标示父节点
					min_flow[i]=MIN(min_flow[temp],(map[temp][i]-flow[temp][i]));//求得min_flow
				}
			}
			if(pre[sink]!=-1)//sink的父节点不为初始值，说明BFS已经找到了一条路径
			{
				int k=sink;
				while(pre[k]>=0)
				{
					flow[pre[k]][k]+=min_flow[sink];//将新的流量加入flow
					flow[k][pre[k]]=-flow[pre[k]][k];
					k=pre[k];
				}
				break;
			}
		}
		if(pre[sink]==-1) return ans;//不存在增广路径，返回
		else ans+=min_flow[sink];
	}	
}
int main()
{
	int m,n;
	while(cin>>n>>m)
	{
		int a,b,cost;
		memset(map,0,sizeof(map));
		for(int i=0;i<n;i++)
		{
			cin>>a>>b>>cost;
			map[a-1][b-1]+=cost;
		}
		cout<<max_flow(m,map,0,m-1)<<endl;
	}
	return 0;
}