POJ 1273 最大流Ford-furkerson & Dinic

网络流---水题 最基本的网络流
从水题开始

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int n_max=205;
int cap[n_max][n_max];
int flow[n_max][n_max];
int que[n_max];
int l[n_max];
bool vis[n_max];
int s,t,n;

int ford_furkerson()
{
	int ret=0;
	while(true)
	{
		memset(vis,0,sizeof(vis));
		int f=0,r=1;
		que[f]=s;
		vis[s]=true;
		bool bans=false;
		while(f<r)
		{
			int i;
			for(i=1;i<=n;i++)
			{
				if(!vis[i]&& flow[ que[f] ][i]<cap[ que[f] ][i])
				{
					l[i]=que[f];
					if(i==t)
					{
						bans=true;
						break;
					}
					que[r++]=i;
					vis[i]=true;
				}
			}
			if(bans)
			{
				break;
			}
			f++;
		}
		if(!bans)
		{
			break;
		}
		int nmin=1<<30;
		int x=t;
		while(x!=s)
		{
			nmin=min(nmin,cap[ l[x] ][x] - flow[ l[x] ][x]);
			x=l[x];
		}
		x=t;
		while(x!=s)
		{
			flow[ l[x] ][x]+=nmin;
			flow[x][ l[x] ]-=nmin;
			x=l[x];
		}
		ret+=nmin;
	}
	return ret;
}

int main()
{
	int m;
	while(~scanf("%d%d",&m,&n))
	{
		memset(cap,0,sizeof(cap));
		memset(flow,0,sizeof(flow));
		s=1,t=n;
		int i,x,y,c;
		for(i=0;i<m;i++)
		{
			scanf("%d%d%d",&x,&y,&c);
			cap[x][y]+=c;
		}
		printf("%d\n",ford_furkerson());
	}
	return 0;
}

Dinic:

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

const int maxn=207;
const int inf=1<<30;
vector<int> next[maxn];
int cap[maxn][maxn];
int d[maxn];
int n,m,s,t;

void addedge(int u,int v,int w)
{
	cap[u][v]+=w;
	next[u].push_back(v);
	next[v].push_back(u);
}

bool bfs()
{
	memset(d,0,sizeof(d));
	queue<int> q;
	q.push(s);
	d[s]=1;
	int u,v;
	while(!q.empty())
	{
		u=q.front();
		q.pop();
		int i;
		for(i=0;i<next[u].size();i++)
		{
			v=next[u][i];
			if(cap[u][v]>0&&d[v]==0)
			{
				d[v]=d[u]+1;
				if(v==t)
				{
					return true;
				}
				q.push(v);
			}
		}
	}
	return false;
}

int dfs(int u,int limit)
{
	if(u==t)
	{
		return limit;
	}
	int i,v,tmp,cost=0;
	for(i=0;i<next[u].size();i++)
	{
		v=next[u][i];
		if(cap[u][v]>0&&d[v]==d[u]+1)
		{
			tmp=dfs(v,min(limit-cost,cap[u][v]));
			if(tmp>0)
			{
				cap[u][v]-=tmp;
				cap[v][u]+=tmp;
				cost+=tmp;
				if(cost==limit)
				{
					break;
				}
			}
			else
			{
				d[v]=-1;
			}
		}
	}
	return cost;
}

int Dinic()
{
	int ret=0;
	while(bfs())
	{
		ret+=dfs(s,inf);
	}
	return ret;
}

int main()
{
	while(~scanf("%d%d",&m,&n))
	{
		memset(cap,0,sizeof(cap));
		int i;
		for(i=1;i<=n;i++)
		{
			next[i].clear();
		}
		int u,v,w;
		for(i=0;i<m;i++)
		{
			scanf("%d%d%d",&u,&v,&w);
			addedge(u,v,w);
		}

		s=1,t=n;
		printf("%d\n",Dinic());
	}
	return 0;
}