poj 1273 Drainage Ditches（网络流最大流）

网络流中的最大流问题。

题目不难，说下数据的意思。

题目有多组测试数据

对于每组测试数据，第一行 n,m 表示n条边和m个顶点

下面 n组数据就是表示u到v之间的最大流量是多少。

这里用的是Edmonds-Karp 最短增广路算法，

算法的思想：每次用BFS找到一条最短增广路，加入最大流中。然后更新残余网络，知道BFS搜索不到路径为止。

具体实现看代码

/*EK*/
#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
using namespace std;
const int Maxsize = 305;
const int inf = 0x3f3f3f3f;
int Graph[Maxsize][Maxsize];
int prev[Maxsize];/*记录当前顶点的前驱顶点，用于路径的遍历*/
bool vis[Maxsize];
int minx(int a,int b)
{
    return a<b?a:b;
}
int bfs(int n,int m)
{
	int pre,nMinFlow = inf;
	queue<int>q;
	memset(prev,0,sizeof(pre));
	memset(vis,false,sizeof(vis));
	prev[1] = 0;
	vis[1] = true;
	q.push(1);
	bool flag = false;
	while(!q.empty())
	{
		pre = q.front();
		q.pop();
		if(pre == m)
		{
			flag = true;
			break;
		}
		for(int i = 1; i <= m && !flag; i++)
		{
			if(Graph[pre][i] > 0 && !vis[i])
			{
				prev[i] = pre;
				vis[i] = true;
				q.push(i);
			}
		}
	}
	if(!flag)
	{
		return 0;
	}
	int v = m;
	while(prev[v])/*每次BFS求出一条nMinFlow*/
	{
		nMinFlow = minx(nMinFlow,Graph[prev[v]][v]);
		v = prev[v];
	}
	v = m;
	while(prev[v])/*残余网络的更新*/
	{
		Graph[prev[v]][v] -= nMinFlow;
		Graph[v][prev[v]] += nMinFlow;
		v = prev[v];
	}
	return nMinFlow;
}
int main()
{
	int n,m,MaxFlow;
	while(scanf("%d %d",&n,&m) != EOF)
	{
	    MaxFlow = 0;
		memset(Graph,0,sizeof(Graph));
		int u,v,w;
		for(int i = 0 ; i < n ; i++)
		{
			scanf("%d %d %d",&u,&v,&w);
			Graph[u][v]+=w;
		}
		int k;
		while(k=bfs(n,m))
		{
			MaxFlow += k;
		}
		printf("%d\n",MaxFlow);
	}
	return 0;
}

/*Dinic*/
#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int vMaxsize = 305;
const int inf = 0x3f3f3f3f;
int res[vMaxsize][vMaxsize];
int dis[vMaxsize];
int maxflow;
int n,m;

int minx(int a,int b)
{
	return a>b?b:a;
}

bool bfs()
{
	queue<int>q;
	memset(dis,0,sizeof(dis));
	int v;
	q.push(1);
	dis[1] = 1;
	while(!q.empty())
	{
		v = q.front();
		q.pop();
		if(v == n)
		{
			return 1;
		}
		for(int i = 1 ; i <= n ; i++)
		{
			if(!dis[i] && res[v][i])
			{
				dis[i] = dis[v] + 1;
				q.push(i);
			}
		}
	}
	return 0;
}

int dfs(int cur,int cp)
{
	if(cur == n)
	{
		return cp;
	}
	int tmp = cp;
	for(int i = 1 ; i <= n ; i++)
	{
		if(res[cur][i] && dis[i]==dis[cur]+ 1 && tmp)
		{
			int t = dfs(i,minx(tmp,res[cur][i]));
			res[cur][i] -= t;
			res[i][cur] += t;
			tmp -= t;
		}
	}
	return cp - tmp;/*dfs的回溯还原*/
}

void dinic()
{
	maxflow = 0;
	while(bfs())
	{
		maxflow += dfs(1,inf);
	}
}

int main()
{
	while(scanf("%d %d",&m,&n)!=EOF)
	{
		memset(res,0,sizeof(res));
		int u,v,w;
		for(int i = 0 ; i < m ; i++)
		{
			scanf("%d %d %d",&u,&v,&w);
			res[u][v] += w;
		}
		dinic();
		printf("%d\n",maxflow);
	}
	return 0;
}