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=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x*=10;x+=ch-'0';ch=getchar();}
    return x*f;
}
int n,m,cnt,ans;
int head[1505],cur[1505],h[1505],q[1505],in[1505];
int day[505],low[100005];
struct data{int to,next,v;}e[100005];
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,0);}
bool bfs(int S,int T)
{
     memset(h,-1,sizeof(h));
     int t=0,w=1;q[0]=S;h[S]=0;
     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]==-1)
              {
                   h[e[i].to]=h[now]+1;
                   q[w++]=e[i].to;
              }
     }
     if(h[T]==-1)return 0;
     return 1;
}
int dfs(int x,int f,int T)
{
     if(x==T)return f;
     int w,used=0;
     for(int i=cur[x];i;i=e[i].next)
          if(h[e[i].to]==h[x]+1)
          {
               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^1].v+=w;
               used+=w;if(used==f)return f;
          }
     if(!used)h[x]=1;
     return used;
}
void dinic(int S,int T)
{while(bfs(S,T)){for(int i=0;i<=n+m+3;i++)cur[i]=head[i];dfs(S,inf,T);}}
bool jud()
{
     int SS=n+m+2,TT=n+m+3;
     for(int i=0;i<=n+m+1;i++)
     {
          if(in[i]>0)insert(SS,i,in[i]);
          if(in[i]<0)insert(i,TT,-in[i]);
     }
     dinic(SS,TT);
     for(int i=head[SS];i;i=e[i].next)
         if(e[i].v)return 0;
     return 1;
}
int main()
{
     while(scanf("%d%d",&n,&m)!=EOF)
     {
          cnt=1;int S=0,T=n+m+1;
          ans=0;
          memset(head,0,sizeof(head));
          memset(in,0,sizeof(in));
          for(int i=1;i<=m;i++)
          {
               int g=read();
               in[T]+=g;
               in[i+n]-=g;
          }
          int ed=0;
          for(int i=1;i<=n;i++)
          {
               int x=read();day[i]=read();
               for(int j=1;j<=x;j++)
               {
                   int num=read();
                   low[++ed]=read();int r=read();
                   insert(i,n+num+1,r-low[ed]);
                   in[i]-=low[ed];
                   in[n+num+1]+=low[ed];
               }
          }
          for(int i=1;i<=n;i++)insert(S,i,day[i]);
          for(int i=1;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^1].v;
               printf("%d
",ans);
               for(int i=1;i<=ed;i++)
                   printf("%d
",e[(i<<1)^1].v+low[i]);
          }
          else printf("-1
");
          puts("");
     }
     return 0;
}

然后来建图：引入源点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 = 2010;
const int MAXE = 1000010;
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, 0, sizeof(head));
        ecnt = 2;
    }

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

    void bfs() {
        memset(dis, 0x3f, sizeof(dis));
        queue<int> que; que.push(ed);
        dis[ed] = 0;
        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 ^ 1] > flow[p ^ 1] && dis[v] > n) {
                    dis[v] = dis[u] + 1;
                    que.push(v);
                }
            }
        }
    }

    int Max_flow(int ss, int tt, int nn) {
        st = ss, ed = tt, n = nn;
        int ans = 0, minFlow = INF, u;
        for(int i = 0; i <= n; ++i) {
            cur[i] = head[i];
            gap[i] = 0;
        }
        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] + 1) {
                    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] ^ 1] -= minFlow;
                        }
                        minFlow = INF;
                    }
                    break;
                }
            }
            if(flag) continue;
            int minDis = n - 1;
            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]] == 0) break;
            ++gap[dis[u] = minDis + 1];
            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, 0, sizeof(f));
        int s = n + m + 1, t = s + 1;
        int ss = t + 1, tt = ss + 1;
        for(int i = 1; i <= m; ++i) {
            scanf("%d", &x);
            f[i] -= x;
            f[t] += x;
            G.add_edge(i, t, INF);
        }
        int cnt = 0;
        for(int i = 1; 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 + 1] += l;
                down[++cnt] = l; id[cnt] = G.ecnt;
                G.add_edge(i + m, x + 1, r - l);
            }
        }
        int sum = 0;
        for(int i = 1; i <= t; ++i) {
            if(f[i] > 0) 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
", G.Max_flow(s, t, tt));
            for(int i = 1; i <= cnt; ++i) printf("%d
", down[i] + G.flow[id[i]]);
        }
        puts("");
    }
}