题意：

给定n个项目，m个技术难题

下面一行n个数字表示每个项目的收益

下面一行m个数字表示攻克每个技术难题的花费

下面n行第i行表示

第一个数字u表示完成 i 项目需要解决几个技术难题，后面u个数字表示需要解决的问题标号。

下面m*m的矩阵

(i,j) = 1 表示要解决j问题必须先解决i问题。

（若几个问题成环，则需要一起解决）

问：最大收益。

思路：

先给问题缩点一下，每个缩点后的点权就是这个点内所有点权和。

然后跑一个最大权闭合图。

#include<stdio.h>  
#include<string.h>  
#include<iostream>  
#include<algorithm>  
#include<vector>  
#include<set>
using namespace std;  
const int MAXN = 1000;//点数的最大值  
const int MAXM = 40010;//边数的最大值  
const int INF = 0x3f3f3f3f;  

#define inf 100000000
struct isap{
    struct Edge  
    {  
        int to,next,cap,flow;  
    }edge[MAXM];//注意是MAXM  
    int tol;  
    int Head[MAXN];  
    int gap[MAXN],dep[MAXN],cur[MAXN];  
    void add(int u,int v,int w,int rw = 0)  
    {  
        edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = 0;  
        edge[tol].next = Head[u]; Head[u] = tol++;  
        edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = 0;  
        edge[tol].next = Head[v]; Head[v] = tol++;  
    }  
    int Q[MAXN];  
    void BFS(int start,int end)  
    {  
        memset(dep,-1,sizeof(dep));  
        memset(gap,0,sizeof(gap));  
        gap[0] = 1;  
        int front = 0, rear = 0;  
        dep[end] = 0;  
        Q[rear++] = end;  
        while(front != rear)  
        {  
            int u = Q[front++];  
            for(int i = Head[u]; i != -1; i = edge[i].next)  
            {  
                int v = edge[i].to;  
                if(dep[v] != -1)continue;  
                Q[rear++] = v;  
                dep[v] = dep[u] + 1;  
                gap[dep[v]]++;  
            }  
        }  
    }  
    int S[MAXN];  
    int sap(int start,int end,int N)  
    {  
        BFS(start,end);  
        memcpy(cur,Head,sizeof(Head));  
        int top = 0;  
        int u = start;  
        int ans = 0;  
        while(dep[start] < N)  
        {  
            if(u == end)  
            {  
                int Min = INF;  
                int inser;  
                for(int i = 0;i < top;i++)  
                    if(Min > edge[S[i]].cap - edge[S[i]].flow)  
                    {  
                        Min = edge[S[i]].cap - edge[S[i]].flow;  
                        inser = i;  
                    }  
                    for(int i = 0;i < top;i++)  
                    {  
                        edge[S[i]].flow += Min;  
                        edge[S[i]^1].flow -= Min;  
                    }  
                    ans += Min;  
                    top = inser;  
                    u = edge[S[top]^1].to;  
                    continue;  
            }  
            bool flag = false;  
            int v;  
            for(int i = cur[u]; i != -1; i = edge[i].next)  
            {  
                v = edge[i].to;  
                if(edge[i].cap - edge[i].flow && dep[v]+1 == dep[u])  
                {  
                    flag = true;  
                    cur[u] = i;  
                    break;  
                }  
            }  
            if(flag)  
            {  
                S[top++] = cur[u];  
                u = v;  
                continue;  
            }  
            int Min = N;  
            for(int i = Head[u]; i != -1; i = edge[i].next)  
                if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)  
                {  
                    Min = dep[edge[i].to];  
                    cur[u] = i;  
                }  
                gap[dep[u]]--;  
                if(!gap[dep[u]])return ans;  
                dep[u] = Min + 1;  
                gap[dep[u]]++;  
                if(u != start)u = edge[S[--top]^1].to;  
        }  
        return ans;  
    }  
    void init(){ tol = 0; memset(Head,-1,sizeof(Head)); } 
} hehe;
inline void rd(int &n){     
    char c = getchar();    
    while(c < '0' || c > '9') c = getchar();   
    n = 0;
    while(c >= '0' && c <= '9') n *= 10, n += (c - '0'),c = getchar();    
}   
#define N 52  
//N为最大点数  
#define M 3000  
//M为最大边数  
struct Edge{  
    int from, to, nex;  
    bool sign;//是否为桥  
}edge[M];  
int head[N], edgenum;  
void add(int u, int v){//边的起点和终点  
    Edge E={u, v, head[u], false};  
    edge[edgenum] = E;  
    head[u] = edgenum++;  
}  
int DFN[N], Low[N], Stack[N], top, Time; //Low[u]是点集{u点及以u点为根的子树} 中(所有反向弧)能指向的(离根最近的祖先v) 的DFN[v]值(即v点时间戳)  
int taj;//连通分支标号，从1开始  
int Belong[N];//Belong[i] 表示i点属于的连通分支  
bool Instack[N];  
vector<int> bcc[N]; //标号从1开始  
void tarjan(int u ,int fa){    
    DFN[u] = Low[u] = ++ Time ;    
    Stack[top ++ ] = u ;    
    Instack[u] = 1 ;    

    for (int i = head[u] ; ~i ; i = edge[i].nex ){    
        int v = edge[i].to ;    
        if(DFN[v] == -1)  
        {    
            tarjan(v , u) ;    
            Low[u] = min(Low[u] ,Low[v]) ;  
            if(DFN[u] < Low[v])  
            {  
                edge[i].sign = 1;//为割桥  
            }  
        }    
        else if(Instack[v]) Low[u] = min(Low[u] ,DFN[v]) ;        
    }    
    if(Low[u] == DFN[u]){    
        int now;  
        taj ++ ; bcc[taj].clear();  
        do{  
            now = Stack[-- top] ;    
            Instack[now] = 0 ;   
            Belong [now] = taj ;  
            bcc[taj].push_back(now);  
        }while(now != u) ;  
    }  
}  

void tarjan_init(int all){  
    memset(DFN, -1, sizeof(DFN));  
    memset(Instack, 0, sizeof(Instack));  
    top = Time = taj = 0;  
    for(int i=0;i<all;i++)if(DFN[i]==-1 )tarjan(i, i); //注意开始点标！！！  
}
vector<int>G[N];  
int du[N];  
void suodian(){  
    memset(du, 0, sizeof(du));  
    for(int i = 1; i <= taj; i++)G[i].clear();  
    for(int i = 0; i < edgenum; i++){  
        int u = Belong[edge[i].from], v = Belong[edge[i].to];  
        if(u!=v)G[u].push_back(v), du[v]++;  
    }  
}  
void init(){memset(head, -1, sizeof(head)); edgenum=0;}  
int ans, n, m;
int a[22], b[52], c[52], sum;
vector<int>D[22];
set<int>myset[22];
void input(){
    int i, j, u;
    rd(n); rd(m);
    sum = 0;
    for(i = 0; i < n; i++)rd(a[i]), sum += a[i];
    for(i = 0; i < m; i++)rd(b[i]);
    for(i = 0; i < n; i++) {
        myset[i].clear();
        D[i].clear();
        rd(j);
        while(j--){
            rd(u);
            D[i].push_back(u);
        }
    }
    init();
    for(i = 0; i < m; i++){
        for(j = 0; j < m; j++)
        {
            rd(u);
            if(u)add(i, j);
        }
    }
    tarjan_init(m);
    suodian();
    for(i = 1; i <= taj; i++){
        c[i] = 0;
        for(j = 0; j < bcc[i].size(); j++)
            c[i] += b[bcc[i][j]];
    }
}
int main() {
    int i, j, T, Cas = 1;rd(T);
    while(T--){
        input();
        ans = 0;
        hehe.init();
        int from = n+m, to = n+m+1;
        for(i = 1; i <= taj; i++)
        {
            hehe.add(i+n-1, to, c[i]);
            for(j = 0; j < G[i].size(); j++)
                hehe.add(i+n-1, G[i][j]+n-1, inf);
        }
        for(i = 0; i < n; i++){
            hehe.add(from, i, a[i]);
            for(j = 0; j < D[i].size(); j++)
            {
                if(myset[i].find(Belong[D[i][j]]+n-1)==myset[i].end())
                hehe.add(i, Belong[D[i][j]]+n-1, inf);
                myset[i].insert(Belong[D[i][j]]+n-1);
            }
        }
        ans = hehe.sap(from, to, n+m+2);
        ans = sum - ans;
        printf("Case #%d: %d\n", Cas++, ans);
    }
    return 0;
}