Human life FZU

Xzz is playing a MMORPG "human life".

In this game, there are N different skills. Some skills may base on another skill.

Learning skill will cost Xzz some money.

And there are M different jobs. If Xzz's skills satisfy the job's requirement, then Xzz can get this job, and get some money.

But some jobs are conflict, some Xzz can't get the job at same time.

There are K pairs of jobs are conflict.

Now Xzz want to know the money he can get at the most，can you help him.

Input

First line of the input file contains an integer T(0 < T ≤ 10) that indicates how many cases of inputs are there.

The description of each case is given below:

The first line of each input case contains number N, M, K. N <= 100, M <= 50, K <= 5.

Then follow N lines. In ith line the first two number ? ,? , means learning skill i const vi , skill i base on another ni skills. The last ni number aij means before learning skill i Xzz need to learn skill aij. 0 ≤ vi ≤ 1000, 0 ≤ ni ≤ N

Then follow M lines. In ith line the first two number wi, mi , means job i earn wi, jobs i base on mi skills. The last mi number bij means get job i need to learn skill bij. 0 ≤ wi ≤ 1000, 0 ≤ mi ≤ M

Then follow K lines. In ith line the first two number ci, di, means job ci conflict with job di.

Output

The description of output for each test case is given below:

The first line of the output for each test case contains number answer, the maximum money Xzz can get.

Sample Input

2
5 2 0
1 0
1 1 1
1 0
1 0
1 1 4
10 2 2 3
8 2 3 5
5 2 1
1 0
1 1 1
1 0
1 0
1 1 4
10 2 2 3
8 2 3 5
1 2

Sample Output

13
7

今天组队训练，这个我负责的图论部分没有写出来 难受啊
今天想拿网络流 流过去结果建图不知道该怎么建图 流也流不对
结束后才知道这就是最大权闭合子图的板子题目
唉 图论的基本套路我都还没有掌握 难受啊

今天然后晚上认真的学习了最大权闭合子图

点击这里学习最大权闭合子图 博主很良心讲的非常好

然后下面这一题就稍微的改动了一下 
一开始我还在想k如何处理 ，后来学长告诉我k最大为5 直接枚举所有情况就好了

然后就是基本的建图操作

#include <cstdio>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>
#include <set>
#include <iostream>
#include <map>
#include <stack>
#include <string>
using namespace std;
#define pi acos(-1.0)
#define eps 1e-6
#define fi first
#define se second
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define bug      printf("******")
#define mem(a,b) memset(a,b,sizeof(a))
#define fuck(x)  cout<<"["<<x<<"]"<<endl
#define f(a)     a*a
#define san(n,m) scanf("%d%d",&n,&m)
#define FIN freopen("in.txt","r",stdin)
#define lowbit(x) x&-x
#pragma comment (linker,"/STACK:102400000,102400000")
using namespace std;
const int maxn = 100004;
typedef long long LL;
const int MX = 450;
const int MXE = 4 * MX * MX;
const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int INF = 0x3f3f3f;
struct MaxFlow {
    struct Edge {
        int v, nxt;
        LL w;
    } E[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) {
        E[tot] = (Edge) {
            v, head[u], w
        };
        head[u] = tot++;
        E[tot] = (Edge) {
            u, head[v], 0
        };
        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 = E[i].nxt) {
                int v = E[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 = E[i].nxt) {
            int v = E[i].v;
            if (E[i].w > 0 && d[u] == d[v] + 1) {
                last[u] = i;
                LL tmp = dfs (v, min (f - sap, E[i].w) );
                E[i].w -= tmp;
                E[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, INFLL);
        return flow;
    }
} F;
int t, n, m, k, vis[505];
struct node {
    int val, n;
    int num[55];
} a[505], b[505];
struct node1 {
    int x, y;
} p[maxn];
int main() {
    scanf("%d", &t);
    while(t--) {
        scanf("%d%d%d", &n, &m, &k);
        for (int i = 1 ; i <= n ; i++) {
            scanf("%d%d", &a[i].val, &a[i].n);
            for (int j = 0 ; j < a[i].n ; j++) scanf("%d", &a[i].num[j]);
        }
        for  (int i = 1 ; i <= m ; i++) {
            scanf("%d%d", &b[i].val, &b[i].n);
            for (int j = 0 ; j < b[i].n ; j++) scanf("%d", &b[i].num[j]);
        }
        for (int i = 0 ; i < k ; i++) scanf("%d%d", &p[i].x, &p[i].y);
        int st = 0, ed = n + m + 1;
        LL ans = 0;
        for (int i = 0 ; i < (1 << k) ; i++) {
            LL sum = 0;
            F.init();
            memset(vis, 0, sizeof(vis));
            for (int j = 0 ; j < k ; j++) {
                if (vis[p[j].x] && vis[p[j].y] ) continue;
                if ((i >> j) & 1) vis[p[j].y] = 1;
                else vis[p[j].x] = 1;
            }
            for (int j = 1 ; j <= m ; j++) {
                if (vis[j]) continue;
                sum += 1LL * b[j].val;
                F.add(st, j, b[j].val);
                for (int p = 0 ; p < b[j].n ; p++) F.add(j, m + b[j].num[p], INF);
            }
            for (int j = 1 ; j <= n ; j++) {
                F.add(m + j, ed, a[j].val);
                for (int p = 0 ; p < a[j].n ; p++) F.add(m + j, m + a[j].num[p], INF);
            }
            LL temp = F.solve(st, ed, n + m + 2);
            ans = max(ans, sum - temp);
        }
        printf("%lld
", ans);
    }
    return 0;
}