bzoj 1391 [Ceoi2008]order - 最小割

Description

有N个工作，M种机器，每种机器你可以租或者买过来. 每个工作包括若干道工序，每道工序需要某种机器来完成,你可以通过购买或租用机器来完成。 现在给出这些参数，求最大利润

Input

第一行给出 N,M(1<=N<=1200,1<=M<=1200) 下面将有N块数据，每块数据第一行给出完成这个任务能赚到的钱(其在[1,5000])及有多少道工序 接下来若干行每行两个数，分别描述完成工序所需要的机器编号及租用它的费用(其在[1,20000]) 最后M行，每行给出购买机器的费用(其在[1,20000])

Output

最大利润

Sample Input

2 3
100 2
1 30
2 20
100 2
1 40
3 80
50
80
110

Sample Output

50

HINT

---

　　有点类似于最大权闭合子图。任务和源点连边，容量为获利，任务和完成它的工序所用机器连边，容量为租用费用，机器和汇点连边，容量为它的价格。答案是总获利 - 最大流。

　　这些都还好。。最坑的是，我的模板在前几道题上正常运行，这道题用vectot炸掉了，一直鬼畜地Runtime Error，我也表示很绝望，换成数组才能Accepted。

Code

/**
 * bzoj
 * Problem#1391
 * Accepted
 * Time:4860ms
 * Memory:46372k
 */
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const int eps = 1e-6;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

typedef class Edge {
    public:
        int end;
        int next;
        int flow;
        int cap;
        Edge(int end = 0, int next = -1, int flow = 0, int cap = 0):end(end), next(next), flow(flow), cap(cap) {    }
}Edge;

typedef class MapManager {
    public:
        int ce;
        Edge* edge;
        int* h;
        
        MapManager():ce(0), h(NULL) {        }
        MapManager(int nodes, int limit):ce(0) {
            h = new int[(const int)(nodes + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, -1, sizeof(int) * (nodes + 1));
        }
        
        inline void addEdge(int from, int end, int flow, int cap) {
            edge[ce] = (Edge(end, h[from], flow, cap));
            h[from] = ce++;
        }
        
        inline void addDoubleEdge(int from, int end, int cap) {
            addEdge(from, end, 0, cap);
            addEdge(end, from, cap, cap);
        }
        
        Edge& operator [] (int pos) {
            return edge[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
#define m_endpos -1

int n, m;
MapManager g;
int s, t;
int sum = 0;

inline void init() {
    readInteger(n);
    readInteger(m);
    g = MapManager(n + m + 3, (n + 1) * (m + 1) * 2);
    s = 0, t = n + m + 1;
    for(int i = 1, a, b; i <= n; i++) {
        readInteger(a);
        readInteger(b);
        g.addDoubleEdge(s, i, a);
        sum += a;
        for(int j = 1, c, d; j <= b; j++) {
            readInteger(c);
            readInteger(d);
            g.addDoubleEdge(i, c + n, d);
        }
    }
    for(int i = 1, a; i <= m; i++) {
        readInteger(a);
        g.addDoubleEdge(i + n, t, a);
    }
}

int* dis;
boolean* vis;
queue<int> que;
inline boolean bfs() {
    memset(vis, false, sizeof(boolean) * (t + 2));
    que.push(s);
    vis[s] = true;
    dis[s] = 0;
    while(!que.empty()) {
        int e = que.front();
        que.pop();
        for(int i = m_begin(g, e); i != m_endpos; i = g[i].next) {
            if(g[i].cap == g[i].flow)    continue;
            int eu = g[i].end;
            if(vis[eu])    continue;
            vis[eu] = true;
            dis[eu] = dis[e] + 1;
            que.push(eu);
        }
    }
    return vis[t];
}

int *cur;
inline int blockedflow(int node, int minf) {
    if((node == t) || (minf == 0))    return minf;
    int f, flow = 0;
    for(int& i = cur[node]; i != m_endpos; i = g[i].next) {
        int& eu = g[i].end;
        if(dis[eu] == (dis[node] + 1) && (f = blockedflow(eu, min(minf, g[i].cap - g[i].flow))) > 0) {
            minf -= f;
            flow += f;
            g[i].flow += f;
            g[i ^ 1].flow -= f;
            if(minf == 0)    return flow;
        }
    }
    return flow;
}

inline void init_dinic() {
    vis = new boolean[(const int)(t + 3)];
    dis = new int[(const int)(t + 3)];
    cur = new int[(const int)(t + 3)];
}

inline int dinic() {
    int maxflow = 0;
    while(bfs()) {
        for(int i = s; i <= t; i++)
            cur[i] = m_begin(g, i);
        maxflow += blockedflow(s, inf);
    }
    return maxflow;
} 

inline void solve() {
    printf("%d\n", sum - dinic());
}

int main() {
//    freopen("order.in", "r", stdin);
    init();
    init_dinic();
    solve();
    return 0;
}