F. Clever King （最小割+最大权闭合子图）

题目链接：https://nanti.jisuanke.com/t/26172

题目大意：King Y想要生产一些产品来提升人们生活的幸福度，现在有n种产品，每种产品 i 都有相对应的价值val[i]（生产这种产品就可以使人们的幸福度提升val[i]）,但生产某种产品都需要先利用n1个矿场和生产n2种其他的产品，矿产总共有m种，使用每个矿场都需要花费相对应的cost[i]，现在要你求出最大的∑val[i]-∑cost[i].

题目思路：以第一个样例为例，我们将每个点都加上权值（val的值就为正，cost的值就为负），再所有有依赖关系的点之间建一条有向边，比如a依赖于b，就建一条a->b的边，这样可以建出如下的图：

这样就可以将问题转化为选择一个权值和最大的子图，使得每个点的后继都在子图里面（这样才会满足所有的依赖条件）；

这样就是变成求最大权闭合子图的问题了，就可以用最小割来解决问题了。

建图思路：先建立一个超级源点st，向每个产品建立一条流量为该产品的价值的边；再建立超级汇点ed，每个矿场向汇点建立一条流量为该矿场的开采的花费的边；产品与产品，产品与矿场之间的依赖关系，如果a依赖于b，就在a与b之间建立一条流量为无穷大的边，最后跑一遍最大流，求出最小割，∑val[i]-最小割便是所求的答案。（注意本题会爆int）

以样例一为例建出的图如下：

AC代码如下：

#include <bits/stdc++.h>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define fi first
#define se second
#define pb push_back
#define MP make_pair
#define FIN freopen("in.txt","r",stdin)
using namespace std;
typedef long long LL;
typedef pair<int,int>pii;
typedef pair<LL,LL>pll;
typedef double db;
const LL inf = 0x3f3f3f3f3f3f3f3f;
const int MX = 405;
const int MXE = 4 * MX * MX;
struct MaxFlow {
    struct Edge {
        int v, nxt;
        LL w;
    } 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, LL 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  vis[MX];
    LL d[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];
    LL dfs(int u, LL f) {
        if (u == t) return f;
        LL 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;
                LL 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;
    }
    LL solve(int st, int ed, int n) {
        LL 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 n,m;
LL val[MX],cost[MX];

int main(){
    int T;cin>>T;
    while(T--){
        F.init();
        scanf("%d%d",&n,&m);
        int st=0,ed=n+m+1;
        LL sum=0;
        for(int i=1;i<=n;i++){
            scanf("%lld",&val[i]);
            sum+=val[i];
            F.add(st,i,val[i]);
        }
        for(int i=1;i<=m;i++){
            scanf("%lld",&cost[i]);
            F.add(i+n,ed,cost[i]);
        }
        for(int i=1;i<=n;i++){
            int n1,n2;
            scanf("%d%d",&n1,&n2);
            for(int j=0;j<n1;j++){
                int x;scanf("%d",&x);
                F.add(i,x+n,inf);
            }
            for(int j=0;j<n2;j++){
                int x;scanf("%d",&x);
                F.add(i,x,inf);
            }
        }
        LL flow=F.solve(st,ed,n+m+2);
        printf("%lld\n",sum-flow);
    }
    return 0;
}