Codeforces 708D - Incorrect Flow

Codeforces 708D - Incorrect Flow

---

链接

 题目大意：

给一个不对的网络流，每次你可以增加/减少一条边的cap或者flow，要求最后网络流是一个可行流

即：

对于每个点进来的流量和出去的流量相同(S，T除外)

对于每条边流量小于等于cap大于等于0

求最少操作次数

n,m 100

---

参考 志愿者招募 ， 考虑原图相当于一堆等式（每个点一个） ，然后很容易发现每条边是只会在一个等式的左边和一个等式的右边的。

那你就可以直接在这两个等式表示的点之间连边来表示一个值的改变对于两个等式的改变。

然后你会发现在1和n处出现了问题。

即：1和n是没有限制的，这样的话会多跑若干个无意义的增广链（比如直接从1到n，因为流量有富裕所以会强行跑）

然后我就自闭了并且口胡了一个最后时刻把这些多余贡献全部减下去的玩意。

实际上完全不必要，可以直接加上一条从n到1（n连的是S）的边，(INF,0)然后只要是以上那种没必要的边就全部会比这条边更劣，于是可以跑出来了。

• 代码

#include<bits/stdc++.h>
using namespace std;
const int N=1010,INF=0x3f3f3f3f,M=2000010;
int n,m;
namespace graph{
	int S,T,cnt=1,hed[N],to[M],nxt[M],cap[M],cost[M];
	inline void adde(int u,int v,int _fl,int _c){
		++cnt;to[cnt]=v,nxt[cnt]=hed[u],cap[cnt]=_fl,cost[cnt]=_c;hed[u]=cnt;
		++cnt;to[cnt]=u,nxt[cnt]=hed[v],cap[cnt]=0,cost[cnt]=-_c;hed[v]=cnt;
	}

	queue<int>Q;
	int d[N];bool vis[N];int incf[N];
	int pre[N];
	bool spfa(){
		for(int i=min(1,S);i<=max(n,T);i++)d[i]=INF;
		memset(vis,0,sizeof(vis));
		Q.push(S);d[S]=0;vis[S]=1;
		incf[S]=INF;
		while(!Q.empty()){
			int u=Q.front();vis[u]=false;Q.pop();
			for(int i=hed[u];i;i=nxt[i]){
				int v=to[i];
				if(!cap[i])continue;
				if(d[v]>d[u]+cost[i]){
					d[v]=d[u]+cost[i];
					incf[v]=min(incf[u],cap[i]);
					pre[v]=i;
					if(!vis[v])vis[v]=true,Q.push(v);
				}
			}
		}
		if(d[T]==INF)return false;
		return true;
	}
	int mincost,maxflow;
	void update(){
		int x=T;
		while(x!=S){
			int i=pre[x];
			cap[i]-=incf[T];
			cap[i^1]+=incf[T];
			x=to[i^1];
		}
		maxflow+=incf[T];
		mincost+=d[T]*incf[T];
	}

	int mincost_maxflow(){
		while(spfa())update();
		return mincost;
	}
}
using namespace graph;
int u[N],v[N],f[N],c[N];
int L[N],R[N];
int ans;

int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d%d%d",&u[i],&v[i],&c[i],&f[i]);
		L[v[i]]+=f[i];R[u[i]]+=f[i];
	}
	S=n+1,T=n+2;
	for(int i=1;i<=n;i++){
		if(R[i]-L[i]>0){
			adde(i,T,R[i]-L[i],0);
		}else{
			adde(S,i,L[i]-R[i],0);
		}
	}
	adde(n,1,INF,0);
	for(int i=1;i<=m;i++){
		if(f[i]<=c[i]){
			adde(u[i],v[i],c[i]-f[i],1);
			adde(u[i],v[i],INF,2);
			adde(v[i],u[i],f[i],1);
		}else{
			ans+=f[i]-c[i];
			adde(u[i],v[i],INF,2);
			adde(v[i],u[i],f[i]-c[i],0);
			adde(v[i],u[i],c[i],1);
		}
	}
	cout<<ans+mincost_maxflow()<<endl;
}