CF 103E Buying Sets 二分图匹配 最大权闭合子图 Hall定理

题意：

给你一些集合，集合内包含一些不同的数字。

满足随机选k个集合，这k个集合的并的数字个数是大于等于k的。

每个集合有一个花费。

现在要找一些集合，使得集合的并的大小等于集合的个数，

并且花费最小，求花费。

题解：

选择一个集合，如果集合里的数字个数大于1，那么肯定需要选择其他的集合来增加集合个数。

可以看到，由于有n个集合，并且又满足任意k个集合数字个数大于等于k，令k=n，则数字个数>=n，又数字大小<=n，所以数字的个数就是n。

可以猜测集合和数字之间可以完美匹配（其实是显然）--hall定理，即一个集合对应一个数字，数字就是该集合的标号。

给集合标号后，我们就可以求集合之间的需求关系了，一个集合要选，则必须选择集合内所有数字对应的集合。

那么就是个最大权闭合子图，权值取负即可。

代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <bitset>
#include <map>
#include <vector>
#include <stack>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <cmath>
#ifdef LOCAL
#define debug(x) cout<<#x<<" = "<<(x)<<endl;
#else
#define debug(x) 1;
#endif

#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
#define lson id<<1,l,mid
#define rson id<<1|1,mid+1,r
#define lowbit(x) x&-x
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, int> pii;

const ll MOD = 1e9 + 7;
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 1e5 + 5;

int m[MAXN];
vector<int> num[MAXN];

const int MX = 666;
int match[MX];
bool vis[MX];

struct Edge {
    int v, nxt;
} E[MAXN];

int Head[MAXN], tot;

void add (int x, int y) {
    E[tot++] = {y, Head[x]};
    Head[x] = tot - 1;
}


bool DFS (int u) {
    //debug(u)
    for (int i = Head[u]; ~i; i = E[i].nxt) {
        int v = E[i].v;
        if (!vis[v]) {
            vis[v] = 1;
            if (match[v] == -1 || DFS (match[v]) ) {
                match[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

int BM (int n) {
    int res = 0;
    memset (match, -1, sizeof (match) );
    for (int u = 1; u <= n; u++) {
        memset (vis, 0, sizeof (vis) );
        if (DFS (u) ) res++;
    }
    return res;
}

const int inf = 0x3f3f3f3f;
const int MXE = 4 * MX * MX;
struct MaxFlow {
    struct Edge {
        int v, w, nxt;
    } edge[MXE];
    int tot, num, s, t;
    int head[MX];
    void init() {
        memset (head, -1, sizeof (head) );
        tot = 0;
    }
    void add (int u, int v, int w) {
        edge[tot].v = v;
        edge[tot].w = w;
        edge[tot].nxt = head[u];
        head[u] = tot++;

        edge[tot].v = u;
        edge[tot].w = 0;
        edge[tot].nxt = head[v];
        head[v] = tot++;
    }

    int  d[MX], vis[MX], gap[MX];
    void bfs() {
        memset (d, 0, sizeof (d) );
        memset (gap, 0, sizeof (gap) );
        memset (vis, 0, sizeof (vis) );
        queue<int>q;
        q.push (t);
        vis[t] = 1;
        while (!q.empty() ) {
            int u = q.front();
            q.pop();
            for (int i = head[u]; ~i; i = edge[i].nxt) {
                int v = edge[i].v;
                if (!vis[v]) {
                    d[v] = d[u] + 1;
                    gap[d[v]]++;
                    q.push (v);
                    vis[v] = 1;
                }
            }
        }
    }

    int last[MX];
    int dfs (int u, int f) {
        if (u == t) return f;
        int sap = 0;
        for (int i = last[u]; ~i; i = edge[i].nxt) {
            int v = edge[i].v;
            if (edge[i].w > 0 && d[u] == d[v] + 1) {
                last[u] = i;
                int tmp = dfs (v, min (f - sap, edge[i].w) );
                edge[i].w -= tmp;
                edge[i ^ 1].w += tmp;
                sap += tmp;
                if (sap == f) return sap;
            }
        }
        if (d[s] >= num) return sap;
        if (! (--gap[d[u]]) ) d[s] = num;
        ++gap[++d[u]];
        last[u] = head[u];
        return sap;
    }

    int solve (int st, int ed, int n) {
        int flow = 0;
        num = n;
        s = st;
        t = ed;
        bfs();
        memcpy (last, head, sizeof (head) );
        while (d[s] < num) flow += dfs (s, inf);
        return flow;
    }
} F;


int v[MX];


int main() {
#ifdef LOCAL
    freopen ("input.txt", "r", stdin);
#endif
    int n;
    cin >> n;
    memset(Head, -1, sizeof(Head));
    for (int i = 1; i <= n; i++) {
        scanf ("%d", &m[i]);
        for (int j = 1; j <= m[i]; j++) {
            int x;
            scanf ("%d", &x);
            num[i].pb (x);
            add (i, x + n);
            add (x + n, i);
        }
    }
    for (int i = 1; i <= n; i++) scanf ("%d", &v[i]), v[i] = -v[i];
    BM (n);
    F.init();
    int tot = 0;
    int st = 0, en = n + n + 10;
    for(int i = n + 1; i <= n + n; i++) match[match[i]] = i;
    for (int i = 1; i <= n; i++) {
        for (int j : num[i]) {
            F.add (match[i] - n, j, INF);
        }
        if (v[i] > 0) F.add (st, match[i] - n, v[i]), tot += v[i];
        else F.add (match[i] - n, en, -v[i]);
    }
    int ret = F.solve (st, en, en + 5);
    printf ("%d\n", - (tot - ret) );

    return 0;

}