poj1273完全不懂为何过的dinic最大流模板

Drainage Ditches

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 67615		Accepted: 26138

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

先来说说dinic，dinic算法可以分为三步，第一步用bfs构建出层次图，第二步用dfs求出一条路的最大流，第三步加和重复以上两步。

其次是关于反向边的理解，当一条边已经被完全占用的时候，可以利用反向边使得另外一条边的流可以从这条边的终点流向起点，其实就是一种替换的意思，用反向边的流替换本不应该从这里流过的流。这里感觉有点说不清楚了，其实本身也不是很明白，虽然看不懂不影响套模板……详细见这个博客https://comzyh.com/blog/archives/568/，对于反相弧说的很好。

贴代码

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;


struct node
{
	int c,f;
};
int INF=10000001;
int d[220],vis[220];
int st,et,i,j,k,m,n;
node map[220][220];

int bfs()
{   
	memset(d,0,sizeof(d));
	queue<int> q;
	q.push(st);
	d[st]=1;
	while(!q.empty())
	{   int pos=q.front();
	    q.pop();
		for(int i=1;i<=n;i++)
		{
			if((map[pos][i].c-map[pos][i].f) && d[i]==0)
		     {
		     	d[i]=d[pos]+1;
		     	q.push(i);
			 }
		}
	}
	if(d[et]==0)return 0;
	  else return 1;
}


int dinic(int pos,int flow)  
{   int ff=flow;
	if(pos==et)return flow;
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		if(d[pos]+1==d[i] && (map[pos][i].c-map[pos][i].f))
		{
			int a=map[pos][i].c-map[pos][i].f;
			int t=dinic(i,min(a,flow));
			map[pos][i].f+=t;
			map[i][pos].f-=t;   //注意反向弧 
			//printf("liu:%d->%d:%d\n",pos,i,t);   
			flow-=t;
			sum+=t;
		}
	}
	return ff-flow;
}

int main()
{
	while(~scanf("%d%d",&m,&n))
	{   memset(map,0,sizeof(map));
		et=n; 
		st=1;
		for(int i=1;i<=m;i++)
		{   int x,y,s;
			scanf("%d%d%d",&x,&y,&s);
			map[x][y].c+=s;  //注意两点间的重边，用加法	
		}
		int Sum=0;
		while(bfs())
		{
			Sum+=dinic(st,INF);
		}
		printf("%d\n",Sum);
	}
	return 0;
 } 

依旧不懂邻接表，依旧不懂前向星，真的要挂了……