hdu 4971

经典闭权和问题，正权的点由源点向该点连边，负权的点由该点向负权连边，做最大流，找到最小割即可，然后由正权点权和减去最小割容量。

AC代码：

#include <cstdio>
#include <cstring>
#include <map>
#include <vector>
#include <algorithm>

using namespace std;
const int maxn = 10007;
const int INF = 10000007;
int n, m;
int head[maxn], edge_number, cur[maxn], dist[maxn], s[maxn], que[maxn], source, dest, flow;
struct Edge {
    int u, v, cap, next;
};
struct Edge edge[maxn];

void addEdge(int u, int v, int cap) {
    edge[edge_number].u = u;
    edge[edge_number].v = v;
    edge[edge_number].cap = cap;
    edge[edge_number].next = head[u];
    head[u] = edge_number;
    edge_number++;

    edge[edge_number].u = v;
    edge[edge_number].v = u;
    edge[edge_number].cap = 0;
    edge[edge_number].next = head[v];
    head[v] = edge_number;
    edge_number++;
}


int bfs() {
    int front = 0;
    int rear = 1;
    memset(dist, -1, sizeof(dist));
    dist[source] = 0;
    que[front] = source;
    while (front < rear) {
        int cnt = que[front];
        for (int i = head[cnt]; i != -1; i = edge[i].next) {
            int v = edge[i].v;
            if (edge[i].cap > 0 && dist[v] == -1) {
                dist[v] = dist[cnt] + 1;
                que[rear++] = v;
                if (v == dest) {
                    return 1;
                }
            }
        }
        front++;
    }
    return 0;
}
int dinic() {
    int top, cnt, min_flow, min_flow_num, flow;
    flow = 0;
    while (bfs()) {
        memcpy(cur, head, sizeof(cur));
        top = 0;
        cnt = source;
        while (1) {
            if (cnt == dest) {
                min_flow = INF;
                for (int i = 0; i < top; i++) {
                    if (edge[s[i]].cap < min_flow) {
                        min_flow = edge[s[i]].cap;
                        min_flow_num = i;
                    }
                }
                for (int i = 0; i < top; i++) {
                    edge[s[i]].cap -= min_flow;
                    edge[s[i] ^ 1].cap += min_flow;
                }
                flow += min_flow;
                top = min_flow_num;
                cnt = edge[s[top]].u;
            }
            for (int i = cur[cnt]; i != -1; cur[cnt] = i = edge[i].next) {
                if (edge[i].cap > 0 && dist[edge[i].v] == dist[cnt] + 1) {
                    break;
                }
            }
            if (cur[cnt] != -1) {
                s[top++] = cur[cnt];
                cnt = edge[cur[cnt]].v;
            }
            else {
                if (top == 0) {
                    break;
                }
                dist[cnt] = -1;
                top--;
                cnt = edge[s[top]].u;
            }
        }
    }
    return flow;
}
int main() {
//    freopen("in.txt", "r", stdin);
    int test_case;
    scanf("%d", &test_case);
    int ncase = 1;
    while (test_case--) {
        edge_number = 0;
        memset(head, -1, sizeof(head));
        scanf("%d%d", &n, &m);
        int sums = 0;
        source = 0;
        dest = n + m + 1;
        for (int i = 1; i <= n; i++) {
            int x;
            scanf("%d", &x);
            addEdge(source, i, x);
            sums += x;
        }
        for (int i = 1; i <= m; i++) {
            int x;
            scanf("%d", &x);
            addEdge(n + i, dest, x);
        }
        for (int i = 1; i <= n; i++) {
            int a;
            scanf("%d", &a);
            for (int j = 1; j <= a; j++) {
                int c;
                scanf("%d", &c);
                addEdge(i, n + 1 + c, INF);
            }
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                int x;
                scanf("%d", &x);
                if (x == 1) {
                    addEdge(n + 1 + i, n + 1 + j, INF);
                }
            }
        }
        int ans = dinic();
        printf("Case #%d: %d\n", ncase, sums - ans);
        ncase++;
    }
    return 0;
}