#include<fstream>
#include<vector>
#include<algorithm>
#include<queue>
#include<cstring>

#define N 110
#define INF 0x3f3f3f3f

using namespace std;

ifstream f("tribut.in");
ofstream g("tribut.out");


int n,m,i,j,y,nr,t[N],tt,mini,sol,x,viz[N],c,D,S,cap[N][N];

queue<int>q;
vector<int>v[N];

int bfs()
{
    memset(viz, 0, sizeof(viz));
    q.push(S);
    viz[S] = 1;

    while(!q.empty())
    {
        x = q.front();
        q.pop();

        if(x == D)
            break;

        for(vector<int>::iterator it = v[x].begin(); it != v[x].end(); ++it)
            if(cap[x][*it] && !viz[*it])
            {
                t[*it] = x;
                q.push(*it);
                viz[*it] = 1;
            }
    }

    while(!q.empty())
        q.pop();

    return viz[D];
}

void max_flow()
{
    while(bfs())
    {
        for(vector<int>::iterator it = v[D].begin(); it != v[D].end(); ++it)
            if(viz[*it])
            {
                mini = INF;
                x = D;
                t[D] = *it;

                while(x != S)
                {
                    mini = min(mini, cap[t[x]][x]);
                    x = t[x];
                }

                sol += mini;

                x = D;
                while(x != S)
                {
                    cap[t[x]][x] -= mini;
                    cap[x][t[x]] += mini;

                    x = t[x];
                }
            }
    }
}

int main()
{
    f >> tt;

    for(; tt; --tt)
    {
        f >> n >> m;

        S = 0;
        D = n + m + 1;

        for(i = 1; i <= n; ++i)
        {
            f >> c;

            v[i + m].push_back(D);
            v[D].push_back(i + m);

            cap[i + m][D] = c;
            cap[D][i + m] = 0;
        }

        for(i = 1; i <= m; ++i)
        {
            f >> nr >> c;

            cap[S][i] = c;
            cap[i][S] = 0;

            v[S].push_back(i);
            v[i].push_back(S);

            for(j = 1; j <= nr; ++j)
            {
                f >> y;

                v[i].push_back(y + m);
                v[y + m].push_back(i);

                cap[i][y + m] = INF;
                cap[y + m][i] = 0;
            }
        }

        sol = 0;
        max_flow();

        g << sol << '\n';

        memset(cap, 0, sizeof(cap));
        for(i = 0; i <= D; ++i)
            v[i].clear();
    }

    return 0;
}