POJ1273 Drainage Ditches(网络流最大流模板)

Drainage Ditches Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 78164   Accepted: 30497 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

题目大意:现在有一个网络流，然后给你个源点和终点，问到源点的最大流量是多少

解题思路:首先对于网络流来说，流向是单向的，所以为了给予程序一个犯错的机会，我们同时加一个反向的网络流，当不能进行增广即结束，我用的方法是Dinic算法，首先我们对网络流进行分层要求流向必须遵循层次流动，不能同层次流动，在当前残余网络中没有增广可能性后，退出，在满足的情况下，利用dfs进行增广

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
typedef long long LL;
const int INF =1e8+5;


int n,m;
int a[205][205];
int dis[205];
bool bfs()//
{
	int k,i;;
	memset(dis,-1,sizeof(dis));
	dis[1]=1;
	queue<int> qua;
	qua.push(1);
	while(!qua.empty())
	{
		k=qua.front();
		qua.pop();
		for(i=1;i<=n;i++)
		{
			if(a[k][i]>0&&dis[i]==-1)
			{
				dis[i]=dis[k]+1;
				qua.push(i);
			}
		}
	}
	if(dis[n]>0)
		return true;
	else
		return false;
}
int dfs(int x,int water)
{
	if(x==n||water==0)
		return water;
	int flow=0;
	for(int i=1;i<=n;i++)
	{
		if(a[x][i]>0&&dis[i]==dis[x]+1&&(flow=dfs(i,min(a[x][i],water))))
		{
			a[x][i]-=flow;
			a[i][x]+=flow;
			return flow;
		}
	}
	return 0;
}
int main()
{
	int flow,i,x,y,c;
	while(cin>>m>>n)
	{
		memset(a,0,sizeof(a));
		for(i=1;i<=m;i++)
		{
			cin>>x>>y>>c;
			a[x][y]+=c;
			a[y][x]+=0;
		}
		flow=0;
		while(bfs())
		{
			flow+=dfs(1,INF);
		}
		cout<<flow<<endl;
	}
	return 0;
}