zoj3229 Shoot the Bullet (有源汇最大流)

题目大意：文文要给幻想乡的女♂孩子们拍照，一共n天，m个女♂孩子，每天文文至多拍D[i]张照片，每个女♂孩子总共要被文文至少拍G[i]次。在第i天，文文可以拍c[i]个女♂孩子，c[i]个女♂孩子中每个女♂孩子在当天被拍的次数是[li,ri]，求最多可以拍多少张照片，以及每天每个可以拍的女♂孩子被拍了多少张照片。

然后就很容易想到一个网络流模型：

n天放左部，m个人放右部，源点向每天连边，容量D[i]，m个人向汇点连边，容量G[i]，左部向右部连边，容量是它们的ri−li，这是有源汇的上下界最大流问题…

首先先做一个有源汇上下界可行流，然后再从残量网络上跑一个s到e的最大流就是答案。

题解

首先S向每天连[0,day]的边，每一天与拍照的妹子连[l,r]的边，每个女孩和汇连[g,oo]的边

对于有源和汇的上下界网络流，只要T到S连一条[0,inf]的边，那么原图成为一个无源点汇点的循环流图，那么新建SS和TT，向每个点连边（即每一点的入流为正则源向其连，否则向汇连），求SS到TT的最大流判断满流

判断有解之后求最大流再做一次S到T的最大流

同时要去掉原来T到S的[0,inf]的边

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #define inf 1000000000
 using namespace std;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x*=;x+=ch-'';ch=getchar();}
     return x*f;
 }
 int n,m,cnt,ans;
 int head[],cur[],h[],q[],in[];
 int day[],low[];
 struct data{int to,next,v;}e[];
 void ins(int u,int v,int w)
 {e[++cnt].to=v;e[cnt].next=head[u];head[u]=cnt;e[cnt].v=w;}
 void insert(int u,int v,int w)
 {ins(u,v,w);ins(v,u,);}
 bool bfs(int S,int T)
 {
      memset(h,-,sizeof(h));
      int t=,w=;q[]=S;h[S]=;
      while(t!=w)
      {
           int now=q[t];t++;
           for(int i=head[now];i;i=e[i].next)
               if(e[i].v&&h[e[i].to]==-)
               {
                    h[e[i].to]=h[now]+;
                    q[w++]=e[i].to;
               }
      }
      if(h[T]==-)return ;
      return ;
 }
 int dfs(int x,int f,int T)
 {
      if(x==T)return f;
      int w,used=;
      for(int i=cur[x];i;i=e[i].next)
           if(h[e[i].to]==h[x]+)
           {
                w=f-used;w=dfs(e[i].to,min(e[i].v,w),T);
                e[i].v-=w;if(e[i].v)cur[x]=i;e[i^].v+=w;
                used+=w;if(used==f)return f;
           }
      if(!used)h[x]=;
      return used;
 }
 void dinic(int S,int T)
 {while(bfs(S,T)){for(int i=;i<=n+m+;i++)cur[i]=head[i];dfs(S,inf,T);}}
 bool jud()
 {
      int SS=n+m+,TT=n+m+;
      for(int i=;i<=n+m+;i++)
      {
           if(in[i]>)insert(SS,i,in[i]);
           if(in[i]<)insert(i,TT,-in[i]);
      }
      dinic(SS,TT);
      for(int i=head[SS];i;i=e[i].next)
          if(e[i].v)return ;
      return ;
 }
 int main()
 {
      while(scanf("%d%d",&n,&m)!=EOF)
      {
           cnt=;int S=,T=n+m+;
           ans=;
           memset(head,,sizeof(head));
           memset(in,,sizeof(in));
           for(int i=;i<=m;i++)
           {
                int g=read();
                in[T]+=g;
                in[i+n]-=g;
           }
           int ed=;
           for(int i=;i<=n;i++)
           {
                int x=read();day[i]=read();
                for(int j=;j<=x;j++)
                {
                    int num=read();
                    low[++ed]=read();int r=read();
                    insert(i,n+num+,r-low[ed]);
                    in[i]-=low[ed];
                    in[n+num+]+=low[ed];
                }
           }
           for(int i=;i<=n;i++)insert(S,i,day[i]);
           for(int i=;i<=m;i++)insert(i+n,T,inf);
           insert(T,S,inf);
           if(jud())
           {
                dinic(S,T);insert(T,S,-inf);//掉原来T到S的[0,inf]的边
                for(int i=head[S];i;i=e[i].next)
                    ans+=e[i^].v;
                printf("%d\n",ans);
                for(int i=;i<=ed;i++)
                    printf("%d\n",e[(i<<)^].v+low[i]);
           }
           else printf("-1\n");
           puts("");
      }
      return ;
 }

然后来建图：引入源点S汇点T，n天一天一点，m个少女每人一点。S到每一天连一条边，上界为Dt，下界为0。每个少女到汇点连一条边，上界为无穷大，下界为Gi。对每一天，连一条边到所有要拍照的少女，下界为L，上界为R。然后引入超级源点SS，超级汇点TT，像无源无汇上下界可行流那样建边，然后T到S连一条边，容量为无穷大。最后从源点S到汇点T跑一遍最大流就是答案，每条边容量的取法和无源无汇上下界可行流一样。

小证明：原图为什么是那样建的我就不解释了。

至于加入超级源点和超级汇点之后为什么要连一条边T→S呢，因为根据无源无汇上下界可行流的做法，原图无源无汇，是应该有一个环的，而现在没有……

之后再从S到T跑一遍，会不会影响之前的流量下界呢？满足下界是来自于点与超级源点和超级汇点之间的边，如果我们把这两个点删掉，边的容量就没法变了，也就不会影响到流量下界。而我没有删掉，是因为若求出可行解之后，超级源点和超级汇点关联的边都应该是满流量的，再跑最大流不可能经过这两个点。

那么跑可行流的时候，和跑最大流的时候，流量是分开算的，那为什么不用加上原来可行流的流量呢？因为原先我们连了一条边T→S，根据无源无汇图中，每个点的入流等于出流，跑可行流的流量已经存在了T→S这条边中，跑最大流就时候，T→S的反向边就有了可行流的容量。所以跑最大流的时候会加上可行流的容量，就不用再加一遍了。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;

 const int MAXN = ;
 const int MAXE = ;
 const int INF = 0x3fff3fff;

 struct SAP {
     int head[MAXN], gap[MAXN], dis[MAXN], pre[MAXN], cur[MAXN];
     int to[MAXE], next[MAXE], flow[MAXE], cap[MAXE];
     int n, ecnt, st, ed;

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

     void add_edge(int u, int v, int c) {
         to[ecnt] = v; cap[ecnt] = c; flow[ecnt] = ; next[ecnt] = head[u]; head[u] = ecnt++;
         to[ecnt] = u; cap[ecnt] = ; flow[ecnt] = ; next[ecnt] = head[v]; head[v] = ecnt++;
         //printf("%d->%d %d\n", u, v, c);
     }

     void bfs() {
         memset(dis, 0x3f, sizeof(dis));
         queue<int> que; que.push(ed);
         dis[ed] = ;
         while(!que.empty()) {
             int u = que.front(); que.pop();
             ++gap[dis[u]];
             for(int p = head[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p ^ ] > flow[p ^ ] && dis[v] > n) {
                     dis[v] = dis[u] + ;
                     que.push(v);
                 }
             }
         }
     }

     int Max_flow(int ss, int tt, int nn) {
         st = ss, ed = tt, n = nn;
         int ans = , minFlow = INF, u;
         for(int i = ; i <= n; ++i) {
             cur[i] = head[i];
             gap[i] = ;
         }
         u = pre[st] = st;
         bfs();
         while(dis[st] < n) {
             bool flag = false;
             for(int &p = cur[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p] > flow[p] && dis[u] == dis[v] + ) {
                     flag = true;
                     minFlow = min(minFlow, cap[p] - flow[p]);
                     pre[v] = u;
                     u = v;
                     if(u == ed) {
                         ans += minFlow;
                         while(u != st) {
                             u = pre[u];
                             flow[cur[u]] += minFlow;
                             flow[cur[u] ^ ] -= minFlow;
                         }
                         minFlow = INF;
                     }
                     break;
                 }
             }
             if(flag) continue;
             int minDis = n - ;
             for(int p = head[u]; p; p = next[p]) {
                 int &v = to[p];
                 if(cap[p] > flow[p] && dis[v] < minDis) {
                     minDis = dis[v];
                     cur[u] = p;
                 }
             }
             if(--gap[dis[u]] == ) break;
             ++gap[dis[u] = minDis + ];
             u = pre[u];
         }
         return ans;
     }
 } G;

 int n, m, c, d, l, r, x;
 int f[MAXN], down[MAXE], id[MAXE];

 int main() {
     while(scanf("%d%d", &n, &m) != EOF) {
         G.init();
         memset(f, , sizeof(f));
         int s = n + m + , t = s + ;
         int ss = t + , tt = ss + ;
         for(int i = ; i <= m; ++i) {
             scanf("%d", &x);
             f[i] -= x;
             f[t] += x;
             G.add_edge(i, t, INF);
         }
         int cnt = ;
         for(int i = ; i <= n; ++i) {
             scanf("%d%d", &c, &d);
             G.add_edge(s, i + m, d);
             while(c--) {
                 scanf("%d%d%d", &x, &l, &r);
                 f[i + m] -= l;
                 f[x + ] += l;
                 down[++cnt] = l; id[cnt] = G.ecnt;
                 G.add_edge(i + m, x + , r - l);
             }
         }
         int sum = ;
         for(int i = ; i <= t; ++i) {
             if(f[i] > ) sum += f[i], G.add_edge(ss, i, f[i]);
             else G.add_edge(i, tt, -f[i]);
         }
         G.add_edge(t, s, INF);
         if(sum != G.Max_flow(ss, tt, tt)) puts("-1");
         else {
             printf("%d\n", G.Max_flow(s, t, tt));
             for(int i = ; i <= cnt; ++i) printf("%d\n", down[i] + G.flow[id[i]]);
         }
         puts("");
     }
 }