ZOJ 2314 Reactor Cooling(无源汇有上下界可行流)

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2314

题目大意：

给n个点，及m根pipe，每根pipe用来流躺液体的，单向的，每时每刻每根pipe流进来的物质要等于流出去的物质，要使得m条pipe组成一个循环体，里面流躺物质。

并且满足每根pipe一定的流量限制，范围为[Li,Ri].即要满足每时刻流进来的不能超过Ri(最大流问题)，同时最小不能低于Li。

解题思路：

转自：https://www.cnblogs.com/WABoss/p/5371871.html

本质上就是求一个无源汇流量有上下界的容量网络的可行流，因为无源汇的容量网络上各个顶点都满足流量平衡条件，即所有点的∑流入流量=∑流出流量，可以看成里面的流是循环流动的，类似有向图欧拉回路。

而带上下界的网络可行流的求法，是根据网络流中一个流是可行流的充分必要条件——限制条件和平衡条件，去改造原网络，转化成不带下界的容量网络来求解的。数学模型那些证明之类的不难理解，见论文《一种简易的方法求解流量有上下界的网络中网络流问题》。

而改造的方式好像有两种挺流行的，我用的做法是：

• 设d[u]为顶点u出边下界和-入边下界和，新建源点、汇点
• 原网络的弧<u,v>容量设置成其上界-下界
• 对于每一个顶点u，如果d[u]<0则源点向其连容量-d[u]的边，否则其向汇点连容量d[u]的边
• 最后如果和源点相关的弧都满流则存在可行流，而各条边的流量+其在原网络的下界就是一个解

代码

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #include<vector>
 #define LL long long
 #define pii pair<int,int>
 #define pll pair<long long,long long>
 #define rep(i,a,b) for(int i=a;i<=b;i++)
 #define per(i,a,b) for(int i=a;i>=b;i--)
 #define FAST_IO ios::sync_with_stdio(false);cin.tie(0);
 #define bug cout<<"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"<<endl;
 #define bugc(_) cout << (#_) << " = " << (_) << endl;
 using namespace std;
 const int N=2e2+;
 const int M=4e4+;
 const int INF=0x3f3f3f3f;

 struct node{
     int to,next,flow;
 }edge[M*];

 int cnt,st,en;
 int head[N],dep[N],d[N],low[M];//d[u]为顶点u出边下界和-入边下界和,low[i]记录第i条边的下界 

 void init(){
     cnt=;
     memset(head,,sizeof(head));
     memset(d,,sizeof(d));
 }

 void link(int u,int v,int flow){
     edge[cnt]=node{v,head[u],flow};
     head[u]=cnt++;
     edge[cnt]=node{u,head[v],};
     head[v]=cnt++;
 }

 int bfs(){
     memset(dep,,sizeof(dep));
     dep[st]=;
     queue<int>q;
     q.push(st);
     while(!q.empty()){
         int u=q.front();
         q.pop();
         for(int i=head[u];i;i=edge[i].next){
             node t=edge[i];
             if(t.flow&&!dep[t.to]){
                 dep[t.to]=dep[u]+;
                 q.push(t.to);
             }
         }
     }
     return dep[en];
 }

 int dfs(int u,int fl){
     if(en==u) return fl;
     int tmp=;
     for(int i=head[u];i&&fl;i=edge[i].next){
         node &t=edge[i];
         if(t.flow&&dep[t.to]==dep[u]+){
             int x=dfs(t.to,min(t.flow,fl));
             if(x>){
                 tmp+=x;
                 fl-=x;
                 t.flow-=x;
                 edge[i^].flow+=x;
             }
         }
     }
     if(!tmp) dep[u]=-;
     return tmp;
 }

 int dinic(){
     int ans=;
     while(bfs()){
         while(int d=dfs(st,INF))
             ans+=d;
     }
     return ans;
 }

 int main(){
     int T;
     scanf("%d",&T);
     while(T--){
         int n,m;
         scanf("%d%d",&n,&m);
         init();
         st=,en=n+;
         for(int i=;i<=m;i++){
             int u,v,c;
             scanf("%d%d%d%d",&u,&v,&low[i],&c);
             link(u,v,c-low[i]);
             d[u]+=low[i];
             d[v]-=low[i];
         }
         int sum=;
         for(int i=;i<=n;i++){
             if(d[i]<) link(st,i,-d[i]);
             else{
                 sum+=d[i];
                 link(i,en,d[i]);
             }
         }
         if(sum!=dinic()) puts("NO");
         else{
             puts("YES");
             for(int i=;i<=*m;i+=){
                 printf("%d\n",edge[i^].flow+low[i>>]);
             }
         }
         puts("");
     }
     return ;
 }