【瞎口胡】上下界网络流

在部分网络流问题中，会要求边的流量在一个区间 \([l,r]\) 之间，即新增了一个对流量下界的限制。

这种问题被称为「上下界网络流」。

如果你不知道什么是网络流，我建议你马上去读这里。

无源汇上下界可行流

求出一组流 \(f\) 使得每个点流量平衡。\(i\) 点是流量平衡的，当且仅当 \(\sum\limits_{j\neq i} f(j,i) = \sum \limits_{j\neq i} f(i,j)\)，即流入流量等于流出流量。

对于第 \(i\) 条边 \((x_i,y_i,(l_i,r_i))\) 至少需要流 \(l_i\) 的流量，我们不妨将这部分流量流完，然后建立一个「残」网络，该网络中第 \(i\) 条边为 \((x_i,y_i,r_i-l_i)\)。

观察到，如果所有点流量平衡，那么我们就找到了一组可行流。反之，设每个点的净流入量（流入 - 流出）为 \(s_i\)，那么：

• 如果 \(s_i=0\)，那么该点流量平衡，我们不用处理这个点。
• 如果 \(s_i>0\)，说明流入的流量过多，我们需要从该点流出 \(s_i\) 的流量到其它点。因此，我们需要一个在残网络上的虚拟源点 \(S'\)，然后从 \(S'\) 流出 \(s_i\) 的流量到 \(i\)。
• 如果 \(s_i<0\)，说明流出的流量过多，我们需要从其它点接受 \(s_i\) 的流量。因此，我们需要一个在残网络上的虚拟汇点 \(T'\)，然后从该点流 \(s_i\) 的流量到 \(T'\)。

最后，在残网络上跑一遍 \(S'\) 到 \(T'\) 的最大流，满流（\(S'\) 流出的流量和 \(T'\) 流入的流量相等）则有一组可行流，否则不存在可行流。

正确性显然。

无源汇上下界最小费用可行流

把最大流改为费用流即可。

总费用即为费用流的费用加上流满每条边下界的费用。

有源汇上下界（最小费用）可行流

区别于无源汇的上下界网络流，有源汇上下界网络流对于源汇 \(S,T\)，只需要满足 \(S\) 的净流出量等于 \(T\) 的净流入量。其它点仍然需要流量平衡。

一种做法是连一条 \((T,S,(0,+\infty))\) 的边，然后就变为了无源汇上下界网络流。\(S\) 到 \(T\) 的流量就是这条边流过的流量。

例题 1 [AHOI2014/JSOI2014]支线剧情

题意

给定 \(n\) 个点和 \(m\) 条边的带权有向图，保证从 \(1\) 开始可以走到全部 \(n\) 个点。每次可以选择一条从 \(1\) 开始的路径，给路径上的每一条边打上一个标记，代价为路径上的边权之和。询问给每条边都打上标记的最小代价。

\(1 \leq n \leq 300,1 \leq m \leq 5000\)，边权 \(w_i\) 满足 \(1 \leq w_i \leq 300\)

题解

每条边至少经过一次等价于至少流过 \(1\) 的流量，因此边 \((u,v,w)\) 在网络流图中表示为 \((u,v,(1,+\infty),w)\)。路径可以在任何点结束，于是建立超级汇点 \(T\)（注意与虚拟汇点 \(T'\) 区分，它们不是同一个点），并对于每个点 \(i\) 连接边 \((i,T,(0,+\infty),0)\)。

然后就是一个源点为 \(1\) 汇点为 \(T\) 的有源汇上下界最小费用可行流。

# include <bits/stdc++.h>

const int N=100010,MAXN=1010,INF=0x3f3f3f3f;

struct Edge{
	int to,next,v,w;
};
int fsum[MAXN],coss;

struct Dinic{
	Edge edge[N];
	int head[MAXN],sum;
	bool vis[MAXN];
	int dis[MAXN],s,t,cost;
	Dinic(){
		sum=1;
		return;
	}
	inline void add(int x,int y,int v,int w){
		edge[++sum]=(Edge){y,head[x],v,w},head[x]=sum;
		return;
	}
	inline void addedge(int x,int y,int v,int w){
		add(x,y,v,w),add(y,x,0,-w);
		return;
	}
	inline bool spfa(void){
		std::queue <int> q; 
		memset(dis,INF,sizeof(dis)),dis[s]=0;
		q.push(s);
		while(!q.empty()){
			int i=q.front();
			q.pop(),vis[i]=false;
			for(int j=head[i];j;j=edge[j].next){
				int to=edge[j].to;
				if(edge[j].v&&dis[to]>dis[i]+edge[j].w){
					dis[to]=dis[i]+edge[j].w;
					if(!vis[to])
						q.push(to),vis[to]=true; 
				}
			}
		}
		return dis[t]<INF;
	}
	int dfs(int i,int flow){
		if(i==t)
			return flow;
		vis[i]=true;
		int maxsum=0;
		for(int j=head[i];j;j=edge[j].next){
			int to=edge[j].to;
			if(vis[to]||!edge[j].v||dis[to]!=dis[i]+edge[j].w)
				continue;
			int res=dfs(to,std::min(edge[j].v,flow));
			flow-=res,maxsum+=res,edge[j].v-=res,edge[j^1].v+=res,cost+=edge[j].w*res;
			if(!flow)
				break;
		}
		vis[i]=false;
		if(!maxsum)
			dis[i]=INF;
		return maxsum;
	}
	inline void solve(void){
		while(spfa()){
			dfs(s,INF);
		}
		return;
	}
}G;
int n;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-')f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int main(void){
	n=read();
	for(int i=1;i<=n;++i){
		int d=read();
		while(d--){
			int to=read(),ti=read();
			G.addedge(i,to,INF,ti);
			++fsum[to],--fsum[i],coss+=ti;
		}
	}
    // n+1 S'
    // n+2 T'
    // n+3 T
	G.s=n+1,G.t=n+2;
	for(int i=1;i<=n;++i)
		G.addedge(i,n+3,INF,0);
	G.addedge(n+3,1,INF,0); // 循环边
	for(int i=1;i<=n;++i){
		if(fsum[i]>0){
			G.addedge(G.s,i,fsum[i],0);
		}else if(fsum[i]<0){
			G.addedge(i,G.t,-fsum[i],0);
		}
	}
	G.solve();
	printf("%d",coss+G.cost);
	return 0;
}

有源汇上下界（最小费用）最大流

首先跑出一组可行流。如果它不存在，那么无解。

这个时候残量网络一定是流量平衡的。我们把 \(S',T'\) 和所有与它们相连的边删掉，再跑一遍 \(S\) 到 \(T\) 的（最小费用）最大流「榨干」剩下的流量即可。最后和可行流的流量相加。

当然实现的时候不删也是可以的，入度为 \(0\) 的 \(S'\) 和出度为 \(0\) 的 \(T'\) 显然也不会影响流量...

有源汇上下界（最小费用）最小流

考虑反向榨干，从 \(T\) 往 \(S\) 跑最大流，然后用可行流的流量减掉。