网络流（一）

网络流（一）

网络流问题是这样的：

• 给定一个有向图 \(G=(V,E)\)，把图中的边看作管道，每条边有一个权值 \(c(u,v)\)，表示该管道的流量上限。
• 给定源点 \(s\) 和汇点 \(t\)，现在假设在 \(s\) 处有一个水源，\(t\) 处有一个蓄水池，问从 \(s\) 到 \(t\) 的最大水流量是多少，类似于这类的问题都可归结为网络流问题。
• 从 \(s\) 到 \(t\) 的一条可流路径称之为增广路。

让我们来对它进行一个形式化。考虑流 \(f\)，它需要满足的条件有：

• 流量不能超过容量。\(f(u,v)\le c(u,v)\)。
• 对于每个点，流进了多少水，就要流出多少水。\(\forall u,\sum_{x}f(x,u)=\sum_{x}f(u,x)\)。
• 为了方便起见，我们还定义一条边的反向边 \((v,u)\) 的流量满足 \(f(v,u)=-f(u,v)\)。稍后我们将会看到这么做有什么用。

对于一个流 \(f\)，残量网络定义为一个点集与边集都和原图相同的图，但 \((u,v)\) 的边权为 \(c(u,v)-f(u,v)\)。

Start

一个显然的想法是考虑贪心：对于一条增广路，我们找到路上的边权最小值 \(x\)，然后将路径上每条边都减去 \(x\)；不断找增广路，最后没有增广路的时候就认为算法结束。

然而有一个很显然的反例：

如果我们不幸地选了 \(1\to 3\to 2\to 4\) 这条增广路，那么一下子就不存在增广路了，求出的流大小为 \(1\)；

然而更优的是 \(1\to 3\to 4\) 与 \(1\to 2\to 4\) 这两条路径，这样的流大小为 \(2\)。

解决方法是建立反向边。我们如果在一条边 \((u,v)\) 上添加了一个大小为 \(k\) 的流，那么不仅要将边 \((u,v)\) 的边权减去 \(k\)，同时还将其反向边 \((v,u)\) 的边权加上 \(k\)。这可以看做一种「反悔」机制。

实际上回忆上面「流」的第三条性质，我们将 \(f(u,v)\) 加上 \(k\) 的同时，自然要给 \(f(v,u)\) 减去 \(k\)。由于残量网络上的边权是 \(c(v,u)-f(v,u)\)，这条边的边权就会加上 \(k\)。

那么我们就有了大致的算法框架：每次在图上只沿着容量 \(>0\) 的边走，如果找到 \(s\) 到 \(t\) 的一条路径，设路径上边权的最小值为 \(w\)，那么就将这条路径上所有边的边权都减去 \(w\)，同时将每条边反向边的边权 \(+w\)，并将最大流的值加上 \(w\)；如果 \(s\) 与 \(t\) 不连通，就认为无法增广，算法结束。

如果每次任意找一条增广路进行增广，我们就得到了 \(\text{Ford-Fulkerson}\) 算法。

你想必有这样的疑惑：建完反向边后，一条边可能会被访问很多次，算法的效率将会很低下；甚至于，增广会不会一直进行下去？我们敏锐地注意到每次增广后最大流必然严格增长，因此增广不会无限地进行下去。但，这仍然无法改变算法效率低下的事实。

事实上，这个算法确实很容易被卡掉。如图所示：（借算导上的图）

Edmond-Karp 增广路算法

我们来进行一些优化。

你想必早已听说过：只要每次使用 \(\text{BFS}\) 找到 \(s\to t\) 的一条最短增广路，增广次数将不超过 \(O(nm)\)。

这里我们来简要证明一下它的复杂度。

对于一条增广路 \(p\)，如果其上一条路径 \((u,v)\in p\) 满足其容量 \(c(u,v)\) 恰为 \(p\) 中所有路径的容量最小值，则称其为 \(p\) 上的关键边。一条增广路上可以有多条关键边。

显然，每条增广路上都至少有一条关键边。这意味着增广路的个数不会超过关键边的个数，也就是说，增广次数不会超过关键边的总数。

我们将证明：每条边成为关键边的次数不超过 \(O(n)\)。一旦该结论成立，关键边的总数将为 \(O(nm)\)，则增广次数不超过 \(O(nm)\)。

为了证明这一结论，我们记 \(\text{Dist}(u)\) 为 \(s\to u\) 的最短路长度，这里边的权重为 \(1\)，且只能经过边权 \(>0\) 的边。

可以证明，无论如何增广，\(\text{Dist}(u)\) 必然不会减少。

对于一条边 \((u,v)\)，当其成为关键边时，由于我们走的是最短路径，故必有 \(\text{Dist}(v)=\text{Dist}(u)+1\)。

由于这条边是增广路上的关键边，因此在增广过后这条边的残存容量将降至 \(0\)；反向边的容量则会相应增加。

想要让这条边再次成为关键边，必须要存在一次增广，使得增广路经过其反向边 \((v,u)\)。

记增广后的最短路长为 \(\text{Dist'}\)，那么有 \(\text{Dist'}(u)=\text{Dist'}(v)+1\le \text{Dist}(v)+1=\text{Dist}(u)+2\)。

这表明每条边每成为一次关键边，\(s\) 到其一端点的最短路长就会 \(+2\)。最短路长最多为 \(n-2\)，则每条边成为关键边的次数不超过 \(\dfrac{n-2}{2}=O(n)\)。这样就完成了我们的证明。

上面的证明其实主要在说明一个事：每条边被访问的次数并不会太多。

由于 \(\text{BFS}\) 的复杂度是 \(O(n+m)\)，该算法的总时间复杂度为 \(O(nm(n+m))=O(nm^2)\)。

Dinic 算法

在 \(\text{Dinic}\) 算法中，我们每次增广前先将图分层。节点 \(u\) 的层次 \(d_u\) 被定义为 \(s\to u\) 最少需要经过的边数。

一次 \(\text{BFS}\) 即可完成分层。分层后，若无法求出 \(t\) 的层次，则不存在增广路，算法终止。

在增广的时候，我们只走满足 \(d_v=d_u+1\) 的边 \((u,v)\)。我们称满足上面等式的边为允许弧。

增广的操作使用 \(\text{DFS}\) 来实现。与 \(\text{Edmond-Karp}\) 算法不同的是，\(\text{Dinic}\) 算法每次会增广多条路径。

\(\text{DFS}\) 的过程中，我们从 \(s\) 出发，每次只走允许弧，同时记录一下流到当前节点时最多能流入的流量 flow；在访问一个节点 \(u\) 时，我们遍历其在残量网络上的每条出边 \((u,v)\)，对 \(v\) 进行 \(\text{DFS}\)（此时传入的 flow 即为 \(\min\{\texttt{flow}-\sum k_v,c(u,v)\}\)），并返回从 \(v\) 所能流出的最大流量 \(k_v\)。\(\text{DFS}\) 的返回值就是 \(\sum_v{k_v}\)。

可以证明，\(\text{Dinic}\) 算法的时间复杂度为 \(O(n^2m)\)，实际表现则快得多，甚至可以处理 \(n,m\le 10^5\) 的网络。

值得一提的是，\(\text{Dinic}\) 算法求解二分图最大匹配的复杂度是 \(O(m\sqrt{n})\)；更一般地，而在边权均为 \(1\) 的图上跑 \(\text{Dinic}\)，复杂度将会是 \(O(m\cdot\min(\sqrt{m},n^{0.67}))\)。

\(\text{Dinic}\) 算法有一个效果显著的优化——当前弧优化。

我们注意到，在一次增广中，如果一条边的流量已经满了，那么这次增广无论如何都不会再走这条边了。

因此，我们对每个节点 \(u\) 记录一条「当前弧」，表示 \(u\) 下一条应该增广的边。下次访问 \(u\) 时，直接从当前弧开始往后遍历出边，就省下了遍历前面那些已经满流的边的时间。

代码实现

int head[MN],nxt[MN],edge[MN],ver[MN],tot=1;
int now[MN],d[MN],n,m,s,t;

void adde(int x,int y,int z){
	ver[++tot]=y,edge[tot]=z,nxt[tot]=head[x],head[x]=tot;
	ver[++tot]=x,edge[tot]=0,nxt[tot]=head[y],head[y]=tot;
}

queue<int>q;

bool bfs(){
	memset(d,0,sizeof(d));
	while(q.size())q.pop();
	q.push(s),d[s]=1,now[s]=head[s];
	while(q.size()){
		int u=q.front();q.pop();
		for(int i=head[u];i;i=nxt[i]){
			if((!edge[i])||d[ver[i]])continue;
			int v=ver[i];now[v]=head[v];
			d[v]=d[u]+1,q.push(v);
			if(v==t)return 1;
		}
	}
	return 0;
}

int dinic(int u,int flow){
	if(u==t)return flow;
	int rest=flow;
	for(int i=now[u];i&&rest;i=nxt[i]){
		now[u]=i;int v=ver[i];
		if(d[v]==d[u]+1&&edge[i]){
			int k=dinic(v,min(rest,edge[i]));
			if(!k)d[v]=0;//去掉增广完毕的节点
			edge[i]-=k,edge[i^1]+=k,rest-=k;
		}
	}
	return flow-rest;
}

void solve(){
	n=read(),m=read(),s=read(),t=read();
	for(int i=1;i<=m;i++){
		int u=read(),v=read(),w=read();
		adde(u,v,w);
	}
	int flow=0,ans=0;
	while(bfs()){
		while(flow=dinic(s,INF))ans+=flow;
		//让一次 BFS 得出的结果可以使用多次
	}
	cout<<ans<<endl;
}