poj 1273 Drainage Ditches【最大流入门】

Drainage Ditches

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 63924		Accepted: 24673

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

题意：把池塘（编号1）里面的水通过若干个渠沟排到小溪（编号n）里面，每个渠沟都有最大容量，求能从池塘排出来的最大水量。 最大流模版

#include<stdio.h>
#include<string.h>
#include<stack>
#include<queue>
#include<algorithm>
#define MAX 1100
#define INF 0x7fffff
using namespace std;
struct node
{
	int from,to,cap,flow,next;
}edge[MAX];
int n,m;
int ans,head[MAX];
int vis[MAX];//用bfs求路径时判断当前点是否进队列，
int dis[MAX];//当前点到源点的距离
int cur[MAX];//保存该节点正在参加计算的弧避免重复计算
void init()
{
	ans=0;
	memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
	edge[ans].from=u;
	edge[ans].to=v;
	edge[ans].cap=w;
	edge[ans].flow=0;
	edge[ans].next=head[u];
	head[u]=ans++;
}
void getmap()
{
	int i,a,b,c;
	while(n--)
	{
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c);//正向建边c为最大容量
		add(b,a,0);//反向建边，
	}
}
int bfs(int beg,int end)
{
	int i;
	memset(vis,0,sizeof(vis));
	memset(dis,-1,sizeof(dis));
	queue<int>q;
	while(!q.empty())
	    q.pop();
	vis[beg]=1;
	dis[beg]=0;
	q.push(beg);
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(i=head[u];i!=-1;i=edge[i].next)//遍历所有的与u相连的边
		{
		    node E=edge[i];
		    if(!vis[E.to]&&E.cap>E.flow)//如果边未被访问且流量未满继续操作
		    {
		    	dis[E.to]=dis[u]+1;//建立层次图
		    	vis[E.to]=1;//将当前点标记
		    	if(E.to==end)//如果当前点搜索到终点则停止搜索  返回1表示有从原点到达汇点的路径
		    	    return 1;
		    	q.push(E.to);//将当前点入队
		    }
		}
	}
	return 0;//返回0表示未找到从源点到汇点的路径
}
int dfs(int x,int a,int end)//把找到的这条边上的所有当前流量加上a（a是这条路径中的最小残余流量）
{
	//int i;
	if(x==end||a==0)//如果搜索到终点或者最小的残余流量为0
	    return a;
	int flow=0,f;
	for(int& i=cur[x];i!=-1;i=edge[i].next)//i从上次结束时的弧开始
	{
		node& E=edge[i];
		if(dis[E.to]==dis[x]+1&&(f=dfs(E.to,min(a,E.cap-E.flow),end))>0)//如果
		{//bfs中我们已经建立过层次图，现在如果 dis[E.to]==dis[x]+1表示是我们找到的路径
		//如果dfs>0表明最小的残余流量还有，我们要一直找到最小残余流量为0
			E.flow+=f;//正向边当前流量加上最小的残余流量
			edge[i^1].flow-=f;//反向边
			flow+=f;//总流量加上f
			a-=f;//最小可增流量减去f
			if(a==0)
			    break;
		}
	}
	return flow;//所有边加上最小残余流量后的值
}
int Maxflow(int beg,int end)
{
	int flow=0;
	while(bfs(beg,end))//存在最短路径
	{
		memcpy(cur,head,sizeof(head));//复制数组
		flow+=dfs(beg,INF,end);
	}
	return flow;//最大流量
}
int main()
{
	int i,j;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		init();
		getmap();
		printf("%d\n",Maxflow(1,m));
	}
	return 0;
}