有源汇有上下界最小流 （ZQU 1592)

这道题跟求最大流的时候差不多。

都是先构造可行流，然后判断是否可行，

可行的话，就利用残余流量，构造从汇点t跑到源点s的最大流，

如何求出答案呢。

在第一次求可行流的dinic后，跟求最大流的时候一样，从t到s是可行流的流量；

这个时候t到s的反向边，也就是s到t的流量就是t到s流的量（因为t到s定义权值为inf，要从这条边算出来，得用inf去减到这条边剩下的才是答案，有点麻烦）

所以反向边是个便捷的求法。

所以在第一次dinic之后，t到s的反向便的流量就是可行流的流量；

然后我们再从t到s跑最大流，看最大能跑掉多少，就是最后的答案。 (这里肯定不会影响可行流！，因为已经在第一次dinic的时候保证了可行（即sum==tmpp))

求第二次dinic的时候，要将s跟t之间的边给去掉。

 #include<cstdio>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 #include<queue>
 using namespace std;
 typedef long long ll;
 const ll maxn=;
 const ll inf=0x3f3f3f3f3f3f3f3f;
 ll vis[maxn];
 ll head[maxn],level[maxn];   //前者为邻接表必要数据，后者为dinic的层 数据
 ll in[maxn];  //一条边的初始流量（最低值  也就是定为下界）
 ll limit[maxn];  //limit为该点的流量   小于0的时候是流出多
 //ll bh[maxn];  //一条边的反向边的流量（正向边流出了多少，反向边就是多少）
                //所以用初始的下界流量+上这个方向边的流量就是最终答案；
                //那么为什么不直接正向呢？？？
                //废话 正向求比较麻烦嘛。  原本的值是可以流的量，正向边流出去后
                //那么答案就是可以流的量减去剩余的量就是答案；
                //所以还不如直接求反向呢
 ll num;  //邻接表
 void init()
 {
     num=-  ;
     memset(head,-,sizeof(head));
 }
 struct node
 {
     ll v,w,next;
 }G[maxn*];
 ll bfs(ll s,ll t)
 {
     queue<ll>q;
     q.push(s);
     memset(level,-,sizeof(level));
     level[s]=;
     while(!q.empty()){
         ll u=q.front();
         q.pop();
         for(ll i=head[u];i!=-;i=G[i].next){
             ll v=G[i].v;
             if(G[i].w>&&level[v]==-){
                 level[v]=level[u]+;
                 q.push(v);
             }
         }
     }
    return level[t];
 }
 ll dfs(ll s,ll t,ll f)
 {
     if(s==t) return f;
     ll ans=;
     for(ll i=vis[s];i!=-;i=G[i].next){
         vis[s]=i;  //当前弧优化
         ll v=G[i].v;
         if(G[i].w>&&level[s]+==level[v]){
             ll d=dfs(v,t,min(G[i].w,f-ans));
             if(d>){
                 G[i].w-=d;
                 G[i^].w+=d;
                 ans+=d;
                 if(ans==f) return ans;
             }
         }
     }
    // if(ans==0) level[s]=0;
     return ans;
 }
 ll dinic(ll s,ll t)
 {
     ll ans=;
     while(){
         ll temp=bfs(s,t);
         if(temp==-) break;
         memcpy(vis,head,sizeof(head));
         ans+=dfs(s,t,inf);
     }
     return ans;
 }
 void build(ll u,ll v,ll w)
 {
     num++;
     G[num].v=v;
     G[num].w=w;
     G[num].next=head[u];
     head[u]=num;

     num++;
     G[num].v=u;
     G[num].w=;
     G[num].next=head[v];
     head[v]=num;
 }
 int main()
 {
     init();
     ll n,m,s,t;
     scanf("%lld%lld%lld%lld",&n,&m,&s,&t);
     for(ll i=;i<=m;i++){
         ll u,v,w1,w2;
         scanf("%lld%lld%lld%lld",&u,&v,&w1,&w2);
       //  in[u]=w1;
         limit[u]-=w1;
         limit[v]+=w1;
         build(u,v,w2-w1);
     }
     ll S=;ll T=n+;
     ll sum=;
     for(ll i=;i<=n;i++){
         if(limit[i]<) build(i,T,-limit[i]);
         if(limit[i]>) build(S,i,limit[i]),sum+=limit[i];
     }
     build(t,s,inf);
     //其实这里应该有上面的limit的变化 只是因为这里的w1为0，所以省略不写。
     ll tmpp=dinic(S,T);
     if(tmpp!=sum) printf("please go home to sleep\n");
     else{
         ll tmp1=G[num].w;
         G[num].w=G[num-].w=;
         ll tmp2=dinic(t,s);
         printf("%lld\n",tmp1-tmp2);
     }
     return ;
 }