#include <bits/stdc++.h>
#define DIM 300
#define INF 2000000000
using namespace std;
class InParser {
private:
	FILE *fin;
	char *buff;
	int sp;

	char read_ch() {
		++sp;
		if (sp == 4096) {
			sp = 0;
			fread(buff, 1, 4096, fin);
		}
		return buff[sp];
	}

public:
	InParser(const char* nume) {
		fin = fopen(nume, "r");
		buff = new char[4096]();
		sp = 4095;
	}

	InParser& operator >> (int &n) {
		char c;
		while (!isdigit(c = read_ch()) && c != '-');
		int sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}

	InParser& operator >> (long long &n) {
		char c;
		n = 0;
		while (!isdigit(c = read_ch()) && c != '-');
		long long sgn = 1;
		if (c == '-') {
			n = 0;
			sgn = -1;
		} else {
			n = c - '0';
		}
		while (isdigit(c = read_ch())) {
			n = 10 * n + c - '0';
		}
		n *= sgn;
		return *this;
	}
};


vector <int> L[DIM];
int capacitate[DIM][DIM],dist[DIM],start[DIM],c[DIM*2];
int t,n,m,i,j,x,nr,val,sursa,dest;

void bfs (int start, int dest){
    for (int i=start;i<=dest;i++)
        dist[i] = INF;
    int  p = 1, u = 1;
    c[1] = start;
    dist[start] = 0;
    while (p <= u){
        int nod = c[p];
        ++p;
        if (nod == dest)
            break;
        for (auto vecin : L[nod]){
            if (!capacitate[nod][vecin])
                continue;
            if (dist[vecin] == INF){
                dist[vecin] = 1 + dist[nod];
                c[++u] = vecin;
            }}}}

int dfs (int nod, int dest, int max_flow){
    if (nod == dest || !max_flow)
        return max_flow;

    int flow = 0;
    for (;start[nod]<L[nod].size();start[nod]++){
        int vecin = L[nod][start[nod]];
        if (!capacitate[nod][vecin] || dist[vecin] != dist[nod] + 1)
            continue;
        int val = dfs (vecin,dest,min(max_flow,capacitate[nod][vecin]));
        capacitate[nod][vecin] -= val;
        capacitate[vecin][nod] += val;
        flow += val;
    }
    return flow;
}

int main (){

    InParser cin ("tribut.in");
    ofstream cout ("tribut.out");

    cin>>t;
    for (;t--;){
        cin>>n>>m;

        sursa = 0, dest = n + m + 1;
        for (i=sursa;i<=dest;++i){
            L[i].clear();
            for (j=sursa;j<=dest;++j)
                capacitate[i][j] = 0;
        }

        for (i=1;i<=n;++i){
            cin>>capacitate[m+i][dest];
            L[m+i].push_back(dest);
            L[dest].push_back(m+i);
        }

        for (i=1;i<=m;++i){
            cin>>nr>>capacitate[sursa][i];
            L[sursa].push_back(i);
            L[i].push_back(sursa);
            for (j=1;j<=nr;++j){
                cin>>x;
                L[i].push_back(m+x);
                L[m+x].push_back(i);
                capacitate[i][m+x] = INF;
            }
        }

        int sol = 0, flux;
        do{
            for (i=sursa;i<=dest;i++)
                start[i] = 0;

            bfs (sursa,dest);
            flux = dfs (sursa,dest,INF);
            sol += flux;
        } while (flux);

        cout<<sol<<"\n";
    }


    return 0;
}