hdoj 5855 Less Time, More profit 【最大权闭合图】

hdoj 5855 Less Time, More profit

题意：$n$个工厂，$m$个商店，第$i$个商店在若干个工厂的支持下可以获利$pro[i]$，第$i$个工厂需要投资$pay[i]$且花费时间$T[i]$，现在要求利润不能少于$L$，问你最小的$t$。

就是一个裸的最大权闭合图，然后套个二分就KO了。保证图的连通，砍掉第 i <script type="math/tex" id="MathJax-Element-10">i</script>个工厂当然要容量无穷大啦。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <cstdlib>
#define ll o<<1
#define rr o<<1|1
#define CLR(a, b) memset(a, (b), sizeof(a))
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 400 + 10;
const int INF = 1e7 + 10;
const int MOD = 1e9 + 7;
void add(LL &x, LL y) { x += y; x %= MOD; }
struct Edge {
    int from, to, cap, flow, next;
};
Edge edge[210 * 210 * 3];
int head[MAXN], cur[MAXN], edgenum;
void init() { CLR(head, -1); edgenum = 0; }
void addEdge(int u, int v, int w) {
    Edge E1 = {u, v, w, 0, head[u]};
    edge[edgenum] = E1;
    head[u] = edgenum++;
    Edge E2 = {v, u, 0, 0, head[v]};
    edge[edgenum] = E2;
    head[v] = edgenum++;
}
bool vis[MAXN]; int dist[MAXN];
bool BFS(int s, int t) {
    queue<int> Q; CLR(dist, -1); CLR(vis, false);
    dist[s] = 0; vis[s] = true; Q.push(s);
    while(!Q.empty()) {
        int u = Q.front(); Q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if(!vis[v] && edge[i].cap > edge[i].flow) {
                dist[v] = dist[u] + 1;
                if(v == t) return true;
                vis[v] = true;
                Q.push(v);
            }
        }
    }
    return false;
}
int DFS(int x, int a, int t) {
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int &i = cur[x]; i != -1; i = edge[i].next) {
        Edge &E = edge[i];
        if(dist[E.to] == dist[x] + 1 && (f = DFS(E.to, min(E.cap - E.flow, a), t)) > 0) {
            E.flow += f;
            edge[i^1].flow -= f;
            flow += f; a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}
int Maxflow(int s, int t) {
    int flow = 0;
    while(BFS(s, t)) {
        memcpy(cur, head, sizeof(head));
        flow += DFS(s, INF, t);
    }
    return flow;
}
int N, M, L;
vector<int> G[210];
int pay[210], pro[210], T[210];
int judge(int o) {
    int s = 0, t = N + M + 1;
    init(); int sum = 0;
    for(int i = 1; i <= N; i++) {
        if(T[i] <= o) {
            addEdge(i, t, pay[i]);
        }
        else {
            addEdge(i, t, INF);
        }
    }
    for(int i = 1; i <= M; i++) {
        for(int j = 0; j < G[i].size(); j++) {
            addEdge(i + N, G[i][j], INF);
        }
        addEdge(s, i + N, pro[i]);
        sum += pro[i];
    }
    return sum - Maxflow(s, t);
}
int main()
{
    int t, kcase = 1; scanf("%d", &t);
    while(t--) {
        scanf("%d%d%d", &N, &M, &L);
        int Max = 0;
        for(int i = 1; i <= N; i++) {
            scanf("%d%d", &pay[i], &T[i]);
            Max = max(Max, T[i]);
        }
        for(int i = 1; i <= M; i++) {
            int k, v; scanf("%d%d", &pro[i], &k);
            G[i].clear();
            while(k--) {
                scanf("%d", &v);
                G[i].push_back(v);
            }
        }
        int l = 1, r = Max, ans1 = -1, ans2;
        while(r >= l) {
            int mid = l + r >> 1;
            int res = judge(mid);
            if(res >= L) {
                ans1 = mid;
                ans2 = res;
                r = mid - 1;
            }
            else {
                l = mid + 1;
            }
        }
        printf("Case #%d: ", kcase++);
        if(ans1 == -1) {
            printf("impossible\n");
        }
        else {
            printf("%d %d\n", ans1, ans2);
        }
    }
    return 0;
}