#include <fstream>
#include <vector>
#include <queue>
using namespace std;
ifstream f("tribut.in");
ofstream g("tribut.out");
int N, M;
queue <int> Q;
int Used[205], T[105], ans;
int TT[205], C[205][205], F[205][205];
vector <int> G[205];
int source, sink;
void addEdge(int x, int y, int cap){
    G[x].push_back(y);
    G[y].push_back(x);
    C[x][y] = cap;
}
void Read(){
    f >> N >> M;
    for(int i = 1; i <= N; i++)
        f >> T[i];
    for(int i = 1; i <= N; i++){
        addEdge(0, i, T[i]);
    }
    sink = N + M + 1;
    for(int i = 1; i <= M; i++){
        int len, p;
        f >> len >> p;
        addEdge(i + N, sink, p);
        for(int j = 1; j <= len; j++){
            int s;
            f >> s;
            addEdge(s, i + N, 1000000000);
        }
    }
}
bool BFS(){
    for(int i = 0; i <= sink; i++)
        TT[i] = -1, Used[i] = 0;
    Q.push(0);
    Used[0] = 1;
    while(!Q.empty()){
        int node = Q.front();
        Q.pop();
        if(node == sink)
            continue;
        for(int i = 0; i < G[node].size(); i++){
            int neighb = G[node][i];
            if(Used[neighb])
                continue;
            if(C[node][neighb] - F[node][neighb] > 0){
                TT[neighb] = node;
                Used[neighb] = 1;
                Q.push(neighb);
            }
        }
    }
    return Used[sink];
}
void maxFlow(){
    int flow = 0;
    while(BFS()){
        int minF = 1000000000;
        for(int i = 0; i < G[sink].size(); i++){
            int neighb = G[sink][i];
            if(C[neighb][sink] - F[neighb][sink] == 0 || !Used[neighb])
                continue;
            TT[sink] = neighb;
            for(int j = sink; j != 0; j = TT[j])
                minF = min(minF, C[TT[j]][j] - F[TT[j]][j]);
            for(int j = sink; j != 0; j = TT[j]){
                F[TT[j]][j] += minF;
                F[j][TT[j]] -= minF;
            }
            flow += minF;
        }
    }
    g << flow << '\n';
}
int main()
{
    int T;
    f >> T;
    while(T--){
        Read();
        maxFlow();
        for(int i = 0; i <= sink; i++){
            for(int j = 0; j < G[i].size(); j++){
                int neighb = G[i][j];
                F[i][neighb] = 0;
                F[neighb][i] = 0;
                C[neighb][i] = C[i][neighb] = 0;
            }
            G[i].clear();
        }

    }
    return 0;
}