ZOJ 2314 Reactor Cooling 带上下界的网络流

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

题意：

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

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

求的是最大流。

很久之前就看了带上下界的网络流，一直没看懂，以为刘汝佳的书上写错了，哈哈~~~

建图：

修改成普通的网络流，但是要保证流量守恒，那么，ss到v的容量，u到tt的容量为 b，而且，要这些附加的边上的流必须满载。

然后题目要求最大的流，那么要把这个可行流找出来，这样，我建边的时候，先不加ss,tt的边，

这样，可行流就在edge[i*2]的地方。

 #include <bits/stdc++.h>

 using namespace std;

 #define inf 0x3f3f3f3f

 const int maxn = ;

 //int low[maxn],in[maxn],out[maxn];

 struct Edge
 {
     int from,to,cap,flow;
 };

 struct Dinic
 {
     int n,m,s,t;
     vector<Edge> edge;
     vector<int> G[maxn];
     bool vis[maxn];
     int d[maxn];
     int cur[maxn];

     void init()
     {
         for(int i=;i<maxn;i++)
             G[i].clear();
         edge.clear();
         memset(d,,sizeof(d));
         memset(vis,,sizeof(vis));
         memset(cur,,sizeof(cur));
     }

     void AddEdge (int from,int to,int cap)
     {
         edge.push_back((Edge){from,to,cap,});
         edge.push_back((Edge){to,from,,});
         m = edge.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }

     bool BFS()
     {
         memset(vis,,sizeof(vis));
         queue<int> Q;
         Q.push(s);
         d[s] = ;
         vis[s] = ;
         while(!Q.empty())
         {
             int x = Q.front();
             Q.pop();
             for(int i=; i<G[x].size(); i++)
             {
                 Edge & e = edge[G[x][i]];
                 if(!vis[e.to]&&e.cap>e.flow)
                 {
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }

     long long DFS(int x,int a)
     {
         if(x==t||a==) return a;
         long long flow = ,f;
         for(int & i = cur[x]; i<G[x].size(); i++)
         {
             Edge & e = edge[G[x][i]];
             if(d[x] + ==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>)
             {
                 e.flow +=f;
                 edge[G[x][i]^].flow -=f;
                 flow +=f;
                 a-=f;
                 if(a==) break;
             }
         }
         return flow;
     }

     int Maxflow (int s,int t) {
         this->s = s;this->t = t;
         int flow = ;
         while(BFS()) {
             memset(cur,,sizeof(cur));
             flow+=DFS(s,inf);
         }
         return flow;
     }

     void print(int cnt) {
         for(int i=;i<cnt;i++)
             printf("%d\n",edge[i*].flow+edge[G[][i]].flow);
     }

 }sol;

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--) {
         int n,m;
         scanf("%d%d",&n,&m);
         int low[maxn],uu[maxn],vv[maxn];
         int sum = ;
         sol.init();
         for(int i=;i<m;i++) {
             int u,v,b,c;
             scanf("%d%d%d%d",&u,&v,&b,&c);
             low[i] = b;
             uu[i] = u;
             vv[i] = v;
             sol.AddEdge(u,v,c-b);
             sum+=b;
            // out[u] +=low[i];
            // in[v] +=low[i];
            // sol.AddEdge(0,v,b);
            // sol.AddEdge(u,n+1,b);
         }

         for(int i=;i<m;i++) {
             sol.AddEdge(,vv[i],low[i]);
             sol.AddEdge(uu[i],n+,low[i]);
         }

         int maxflow = sol.Maxflow(,n+);
         if(sum!=maxflow)
             puts("NO");
         else {
             puts("YES");
           //  for(int i=0;i<sol.G[0].size();i++) {
             //    printf("%d\n",sol.edge[sol.G[0][i]].flow);
            // }
             sol.print(m);
         }
     }
     return ;
 }