Shoot the Bullet 【ZOJ - 3229】【有源汇有上下界最大流】

题目链接

---

  题意：有N天，M个妹纸，接下来是一行共M个数，表示M个妹纸要求你在N天内总共给他们拍摄至少Gi个照片。然后有N天，每天有个Ci和Di，表示今天有Ci个妹纸要拍摄，但是今天最多拍摄Di张照片，然后是Ci个妹纸，第一个是妹纸的编号，0～M-1，然后是L～R，表示这个妹纸要求你最少拍L张照片，最多拍R张。

解

  这道题，由于我ISAP的退出的顶端高度没有写好，竟然WA了几十次，加上一整个晚上的自闭。

  终于，我给我的顶端加了1，过了。这里ISAP的高度必须是结点数+1，而又有结点数是从0开始的，所以，我们必须将更新更新为0～node+2，为什么是“node + 2”，因为node + 2，是第一个不可行的高度。必须初始化到node + 2。

  关于ISAP的方面就讲那么多了，接下去是关于这道题的解题思路了。

  首先，每个妹纸至少总共拍Gi张照片，也就是确定了下限是Gi，所以在这里要先处理下限；

  再则，每天至少0张，至多Di张照片，我们得知了上限；

  然后，每个妹纸每天拍Li～Ri张照片，说明的是有上下限。

  于是，根据上述几则条例，我们可以确定如何建图，然后就是直接跑一个最大流即可，最大流*2是否等于|入流 - 出流|总和，是判断有无解的标准。

  有解的时候，我们删除超级源汇点，将原来的源点和汇点变成现在的源汇点，再跑一次最大流，即可得知每条边的流量，加上下限，也就是每条边的实际流了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x7f7f7f7f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1505, maxM = 8e5 + 7;
int N, M, head[maxN], cnt, du[maxN], _Index, line[maxM], fl[maxM], sum;
struct Eddge
{
    int nex, to, flow;
    Eddge(int a=-1, int b=0, int c=0):nex(a), to(b), flow(c) {}
}edge[maxM];
inline void addEddge(int u, int v, int f)
{
    edge[cnt] = Eddge(head[u], v, f);
    head[u] = cnt++;
}
inline void _add(int u, int v, int f) { addEddge(u, v, f); addEddge(v, u, 0); }
struct ISAP
{
    int S, T, gap[maxN], cur[maxN], deep[maxN], que[maxN], ql, qr;
    inline void init()
    {
        for(int i=0; i<=T + 2; i++)
        {
            gap[i] = deep[i] = 0;
            cur[i] = head[i];
        }
        ++gap[deep[T] = 1];
        que[ql = qr = 1] = T;
        while(ql <= qr)
        {
            int u = que[ql ++];
            for(int i=head[u], v; ~i; i=edge[i].nex)
            {
                v = edge[i].to;
                if(!deep[v]) { ++gap[deep[v] = deep[u] + 1]; que[++qr] = v; }
            }
        }
    }
    inline int aug(int u, int Flow)
    {
        if(u == T) return Flow;
        int flow = 0;
        for(int &i = cur[u], v; ~i; i=edge[i].nex)
        {
            v = edge[i].to;
            if(deep[u] == deep[v] + 1)
            {
                int tmp = aug(v, min(edge[i].flow, Flow));
                flow += tmp; Flow -= tmp; edge[i].flow -= tmp; edge[i ^ 1].flow += tmp;
                if(!Flow) return flow;
            }
        }
        if(!(--gap[deep[u]])) deep[S] = T + 2;
        ++gap[++deep[u]]; cur[u] = head[u];
        return flow;
    }
    inline int Max_Flow()
    {
        init();
        int ret = aug(S, INF);
        while(deep[S] <= T + 1) ret += aug(S, INF);
        return ret;
    }
} mf;
inline void init()
{
    cnt = 0; mf.S = N + M + 2; mf.T = N + M + 3; _Index = 0; sum = 0;
    for(int i=0; i<=N + M + 3; i++) { head[i] = -1; du[i] = 0; }
}
int main()
{
    while(scanf("%d%d", &N, &M) != EOF)
    {
        init();
        int s = 0, t = N + M + 1;
        for(int i=1, Gi; i<=M; i++)
        {
            scanf("%d", &Gi);
            _add(i + N, t, INF);
            du[i + N] -= Gi; du[t] += Gi;
        }
        for(int day = 1, Ci, Di; day <= N; day++)
        {
            scanf("%d%d", &Ci, &Di);
            _add(s, day, Di);
            for(int i=1, id, l, r; i<=Ci; i++)
            {
                scanf("%d%d%d", &id, &l, &r); id += N + 1;
                _add(day, id, r - l);
                du[day] -= l; du[id] += l;
                line[++_Index] = cnt - 1; fl[_Index] = l;
            }
        }
        for(int i=0; i<=t; i++)
        {
            if(du[i] > 0)
            {
                _add(mf.S, i, du[i]);
                sum += du[i];
            }
            else if(du[i] < 0)
            {
                _add(i, mf.T, -du[i]);
                sum -= du[i];
            }
        }
        _add(t, s, INF);
        if(mf.Max_Flow() * 2 != sum) { printf("-1\n\n"); continue; }
        head[mf.S] = head[mf.T] = -1;
        mf.S = s; mf.T = t;
        printf("%d\n", mf.Max_Flow());
        for(int i=1; i<=_Index; i++)
        {
            printf("%d\n", fl[i] + edge[line[i]].flow);
        }
        printf("\n");
    }
    return 0;
}