ZOJ 3229 Shoot the Bullet（有源汇的上下界最大流）

Description

Gensokyo is a world which exists quietly beside ours, separated by a mystical border. It is a utopia where humans and other beings such as fairies, youkai(phantoms), and gods live peacefully together. Shameimaru Aya is a crow tengu with the ability to manipulate wind who has been in Gensokyo for over 1000 years. She runs the Bunbunmaru News - a newspaper chock-full of rumors, and owns the Bunkachou - her record of interesting observations for Bunbunmaru News articles and pictures of beautiful danmaku(barrange) or cute girls living in Gensokyo. She is the biggest connoisseur of rumors about the girls of Gensokyo among the tengu. Her intelligence gathering abilities are the best in Gensokyo!

During the coming n days, Aya is planning to take many photos of m cute girls living in Gensokyo to write Bunbunmaru News daily and record at least G_x photos of girl x in total in the Bunkachou. At the k-th day, there are C_k targets, T_k1, T_k2, ..., T_kCk. The number of photos of target T_ki that Aya takes should be in range [L_ki, R_ki], if less, Aya cannot write an interesting article, if more, the girl will become angry and use her last spell card to attack Aya. What's more, Aya cannot take more than D_k photos at the k-th day. Under these constraints, the more photos, the better.

Aya is not good at solving this complex problem. So she comes to you, an earthling, for help.

Input

There are about 40 cases. Process to the end of file.

Each case begins with two integers 1 <= n <= 365, 1 <= m <= 1000. Then m integers, G₁, G₂, ..., G_m in range [0, 10000]. Then n days. Each day begins with two integer 1 <= C <= 100, 0 <= D<= 30000. Then C different targets. Each target is described by three integers, 0 <= T < m, 0 <= L <= R <= 100.

Output

For each case, first output the number of photos Aya can take, -1 if it's impossible to satisfy her needing. If there is a best strategy, output the number of photos of each girl Aya should take at each day on separate lines. The output must be in the same order as the input. If there are more than one best strategy, any one will be OK.

Output a blank line after each case.

题目大意：文文要要给幻想乡中的少女拍照。一共有n天，m个少女，在这n天中文文至少要给少女i(i＜m)拍Gi张照片。在第t（t＜n）中，只能拍Dt张照片，只能给特定的Ct个人拍照，而且每个人至少拍L张，但是少女只给文文拍R张。问文文能否完成任务，在完成任务的情况下最多能拍多少张照片。

思路：预备知识，无源无汇的上下界可行流，见SGU 194 Reactor Cooling（无源无汇上下界可行流）

然后来建图：引入源点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的反向边就有了可行流的容量。所以跑最大流的时候会加上可行流的容量，就不用再加一遍了。

PS：之前以为输出每天的拍照数，后面跑样例的时候发现输出不对……然后把输出改成每天每人，忘了改数组大小RE了一遍>_<

代码（190MS）：

 #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("");
     }
 }