#include <bits/stdc++.h>
#define DIM 210
#define INF 1000000000
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];
deque <int> c;
int capacitate[DIM][DIM],dist[DIM],st[DIM];
int t,n,m,i,j,x,nr,val,sursa,dest;


void bfs (int sursa, int dest){
    for (int i=sursa;i<=dest;i++)
        dist[i] = INF;

    c.clear();
    c.push_back(sursa);
    dist[sursa] = 0;
    while (!c.empty()){
        int nod = c.front();
        c.pop_front();
        if (nod == dest)
            break;
        for (auto vecin : L[nod]){
            if (!capacitate[nod][vecin])
                continue;
            if (dist[vecin] == INF){
                dist[vecin] = 1+dist[nod];
                c.push_back(vecin);
            }}}}
int dfs (int nod, int dest, int max_flow){
    if (nod == dest || !max_flow)
        return max_flow;
    int flow = 0;
    for (;st[nod]<L[nod].size();st[nod]++){
        int vecin = L[nod][st[nod]];
        if (!capacitate[nod][vecin] || dist[vecin] != dist[nod]+1)
            continue;
        int val = dfs (vecin,dest,min(capacitate[nod][vecin],max_flow-flow));
        flow += val;
        capacitate[nod][vecin] -= val;
        capacitate[vecin][nod] += 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[sursa][i];
            L[sursa].push_back(i);
            L[i].push_back(sursa);
        }

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

        int sol = 0, flux;
        do{
            for (int i=sursa;i<=dest;i++)
                st[i] = 0;
            bfs (sursa, dest);
            flux = dfs (sursa,dest,INF);
            sol += flux;

        } while (flux);

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


    return 0;
}