增广路求最大流：EK算法详解

算法简介：

EK算法，全称Edmonds-Karp算法。我个人认为学习一个新算法时有必要去记一下算法的英文全称，可以在同学们面前装逼（但是别装过头了，挨打了不是我的责任......）！最坏情况下的时间复杂度O（n*m^2）。我这个版本用BFS找增广路（当然也可以用DFS，但是时间复杂度......），存图用邻接表。不会BFS和邻接表的同学请......

--------------------------------------------------我是华丽的分割线--------------------------------------------------

基本概念：

在一个有向图中（如下图），节点1只出不进，叫做源点。节点6只入不出，叫做汇点。现在要把一坨（不要吐槽这个量词）物品要从节点1（即源点）送到节点6（即汇点），可以从其他节点中转。每条边都有一个权值，叫做容量（capacity），经过边的物品数量不能超过容量。实际经过边的物品数量叫做流量（flow）。要求最多能送多少物品从节点1到节点6。类似于这样的问题就称为最大流问题。很显然，每条边在即使在最优状态下运送的物品数量也不一定能达到这条边的容量。

对于一条边（u，v），它的容量我们记作c（u，v）；它的流量记作f（u，v）。对于不存在的边（u，v），我们记作f（u，v）=0。我们禁止诸如此类的操作：把4个物品从u送到v，然后又把3个物品从v送到u。这样很多余，我们直接理解为把1个物品从u送到v。相似地，对于f（u，v）=-1，我们理解为把1个物品从v送到u。这样就可以肯定f（u，v）和f（v，u）中最多只有1个正数（但是也能两个都为0）。接下来不难发现最大流问题中有这样3个性质：

容量限制：f（u，v）≤c（u，v）

斜对称性：f（u，v）=-f（v，u）

流量平衡：对于不是源点或汇点的任意节点u，满足，即送出的物品等于送入的物品。

--------------------------------------------------我说过我是谁了--------------------------------------------------

算法详解：

我们在图中找到一条从源点到汇点的路径（这条路径上的每一条边都必须还要有残量，即还能继续加流量），这条路叫做增广路。令delta=路径上所有边的残量的最小值，然后把每一条边的流量都加上delta，这个过程叫做增广。当找不到增广路时来增广时，那么就得到最优解了。找增广路用BFS来找即可（不怕TLE的童鞋可以写DFS）。看起来好像没毛病，可惜这个想法还有那么一点点问题，考虑下面这个图：其中1为源点，4为汇点。

假设刚开始我们找到的一条增广路为1->2->3->4，并且我们对他进行了增广。不难发现接下来已经找不到增广路了，所以按照上述方法求得此图的答案为10。

但是其实还存在更优的方案，先增广1->2->4，再增广1->3->4，这样求得的答案为20！！！

我们发现，由于没有给其一个“反悔”的机会，所以求得了一个错误的答案。

如何解决呢？难道写一个回溯？但是时间复杂度......

解决方案：对于每一条边（u，v），我们再建一条它的反向边（v，u），并让c（v，u）=0。当我们把f（u，v）+=delta时，就执行f（v，u）-=delta。此时如果先找到增广路1->2->3->4后，还会再找到一条增广路1->3->2->4。观察后不难发现，实质上就是找到了两条增广路：1->2->4和1->3->4，正是最优解。至于为什么这样是对的，留给读者思考。

--------------------------------------------------我已经第三次和你们见面了--------------------------------------------------

最后贴上代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
const int maxn=105,maxe=105,INF=0x3F3F3F3F;
using namespace std;

inline int read()					//读入优化
{
	int ret=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-f;ch=getchar();}
	while(ch>='0'&&ch<='9'){ret=ret*10+ch-'0';ch=getchar();}
	return ret*f;
}

struct Graph				//用于保存一个图，通过领接表实现
{
	int n,tot,s,t；
	int lnk[maxn],cap[maxe*2],flow[maxe*2],fa[maxe*2],son[maxe*2],nxt[maxe*2];
	void AddEdge(int u,int v,int c,int f)	//在图中添加一条从u到f，容量为c，流量为f的边
	{
		tot++;
		fa[tot]=u;
		son[tot]=v;
		cap[tot]=c;
		flow[tot]=f;
		nxt[tot]=lnk[u];
		lnk[u]=tot;
	}
	void Input()					//读入并建好一个图
	{
		n=read();int m=read();
		s=read();t=read();
		for(int i=1;i<=m;i++)
		{
			int from=read(),to=read(),capacity=read();
			AddEdge(from,to,capacity,0);
			AddEdge(to,from,0,0);
		}
	}
}Gra;

int EdmondsKarp(Graph& G)		//用EK求图G的最大流
{
	int ans=0,res[maxn],path[maxn],que[maxn];
	//res[i]存刷到i时的最小残量，path用来记录路径
	memset(path,0,sizeof(path));
	while(true)					//不停刷BFS来找增广路
	{
		memset(res,0,sizeof(res));
		memset(que,0,sizeof(que));
		memset(path,0,sizeof(path));
		int head=0,tail=1;
		que[1]=G.s;
		res[G.s]=INF;
		while(head!=tail)
		{
			head++;
			for(int i=G.lnk[que[head]];i;i=G.nxt[i])//枚举从节点que[head]连出来的编号为i的边
			{
				if(!res[G.son[i]]&&G.cap[i]>G.flow[i])
				//如果res[G.son[i]]为0说明当前刷到的路径里还没有G.son[i]这个节点，否则就可能刷死循环
				//如果G.cap[i]>G.flow[i]说明这条边还有残量
				{
					path[G.son[i]]=i;//记下路径
					res[G.son[i]]=min(res[que[head]],G.cap[i]-G.flow[i]);//刷出路上的最小残量
					tail++;
					que[tail]=G.son[i];
				}
			}
			if(res[G.t]) break;//刷到汇点了，找到一条增广路
		}
		if(!res[G.t]) break;//没用找到增广路，则已经求得最大流，结束即可
		for(int u=G.t;u!=G.s;u=G.fa[path[u]])//修正增广路上边的流量
		{
			G.flow[path[u]]+=res[G.t];//当前弧的流量加上增量
			if(path[u]&1)				//它的反向弧上减去增量
				G.flow[path[u]+1]-=res[G.t];
			else
				G.flow[path[u]-1]-=res[G.t];
		}
		ans+=res[G.t];//累加答案
	}
	return ans;
}

int main()
{
	Gra.Input();
	printf("%d\n",EdmondsKarp(Gra));
	return 0;
}

写在后面：

本文由Vintex工作室XZY提供，欢迎加入Vintex QQ交流群：235527313

如需转载，请先联系博主。