最大流 EdmondsKarp演算法

Edmonds_Karp演算法模板

鄰接矩陣形式

#include<iostream>
#include<cstring>
#include<queue>

using namespace std;
const int N=205;
const int INF=0x3f3f3f3f;
int g[N][N];
int pre[N];//路徑上每個結點的前驅結點
bool vis[N];
int n,m;//m是頂點數目，頂點編號從1開始 1是源，m是匯，n是邊數

int EdmondsKarp()
{
	int i,v;
	queue<int>q;
	memset(pre,-1,sizeof(-1));
	memset(vis,0,sizeof(vis));
	pre[1]=0;
	vis[1]=1;
	q.push(1);
	bool flag=false;//標記bfs是否尋找到一條源到匯的可行路徑
	while(!q.empty()){
		v=q.front();
		q.pop();
		for(int i=1;i<=m;i++)
		  if(g[v][i]>0&&vis[i]==0){//必須是依然有容量的邊，才可以走 
		      pre[i]=v;
		      vis[i]=1;
		      if(i==m){
		      	flag=true;
		      	break;
			  }
			  else
			    q.push(i);
		  } 
	}
	if(!flag)//找不到就退出 
	  return 0;
	int ans=INF;
	v=m;
	//尋找源到匯路徑上容量最小的邊，其容量就是此次增加的總流量
	while(pre[v]){
		ans=min(ans,g[pre[v]][v]);
		v=pre[v];
	} 
	//沿此路徑新增反向邊，同時修改路徑上每條邊的容量
	v=m;
	while(pre[v]){
		g[pre[v]][v]-=ans;
		g[v][pre[v]]+=ans;
		v=pre[v];
	}
	return ans; 
}

int main()
{
	while(cin>>n>>m){//m是頂點數目，頂點編號從1開始
		int s,e,c;
		memset(g,0,sizeof(g));
		for(int i=1;i<=n;i++){
			cin>>s>>e>>c;
			g[s][e]+=c;//兩點之間可能有多條邊 
		} 
		int ans=0,tmp;
		while(tmp=EdmondsKarp())
		  ans+=tmp;
		cout<<ans<<endl;
	}
	return 0;
}

鄰接表形式（前向星實現）

#include<iostream>
#include<cstring>
#include<algorithm> 
#include<queue>

using namespace std;

const int N=4005;
const int INF=0x3f3f3f3f;

//前向星實現圖的鄰接表

int M,head[N];

struct Edge{
	int next,to,w;
}edge[N];

void add(int from,int to,int w)
{
	edge[M].next=head[from];
	edge[M].to=to;
	edge[M].w=w;
	head[from]=M++;
}

struct Pre{
	int u,id;
}pre[N];

bool vis[N];
int n,m;

int EdmondsKarp()
{
	queue<int>q;
	memset(vis,false,sizeof(vis));
	vis[1]=true;
	q.push(1);
	bool flag=false;
	int u,v,w;
	//尋找從源到匯的一條增廣路徑
	while(!q.empty())
	{
		u=q.front();
		q.pop();
		for(int k=head[u];k!=-1;k=edge[k].next)
		{
			v=edge[k].to;
			w=edge[k].w;
			if(w>0&&!vis[v])//必須是依然有容量的邊，才可以走 
			{
				pre[v].u=u;//記錄v的前驅結點 
				pre[v].id=k;//記錄 u->v的邊號 
				vis[v]=true;
				if(v==n)
				{
					flag=true;//找到一條增廣路徑 
					break;
				}
				else
				  q.push(v);
			}
		}
	}
	if(!flag)//找不到就退出 
	  return 0; 
	int ans=INF;

	//尋找源到匯路徑上容量最小的邊，其容量就是此次增加的總流量
	for(v=n;v!=1;v=pre[v].u)
	  ans=min(ans,edge[pre[v].id].w);

	//沿此路徑新增反向邊，同時修改路徑上每條邊的容量
	for(v=n;v!=1;v=pre[v].u)
	{
		edge[pre[v].id].w-=ans;
		edge[(pre[v].id)^1].w+=ans;// (pre[v].id)^1是編號為 pre[v].id的反向邊編號 
	} 
	return ans; 
}



int main()
{
	while(~scanf("%d%d",&m,&n))
	{
		int from,to,w;
		M=0;
		memset(head,-1,sizeof(head));
		for(int i=1;i<=m;i++)
		{
			scanf("%d%d%d",&from,&to,&w);
			add(from,to,w);
			add(to,from,0);//新增反向邊 
		}
		int ans=0,temp;
		while(temp=EdmondsKarp())
		  ans+=temp;
		printf("%d\n",ans); 
	}
	return 0;
}