/**
 * Code by Patrick Sava
 * "Spiru Haret" National College of Bucharest
 **/

# include "fstream"
# include "cstring"
# include "vector"
# include "queue"
# include "bitset"
# include "algorithm"
# include "map"
# include "unordered_map"
# include "deque"
# include "string"
# include "iomanip"
# include "cmath"
# include "stack"
# include "cassert"

const char IN [ ] =  "tribut.in" ;
const char OUT [ ] = "tribut.out" ;
const int MAX = 1014 ;

# define pb push_back
# define mp make_pair
# define FORN( a , b , c ) for ( int a = b ; a <= c ; ++ a )
# define FORNBACK( a , b , c ) for ( int a = b ; a >= c ; -- a )

using namespace std ;

ifstream cin ( IN ) ;
ofstream cout ( OUT ) ;

vector < int > gr [ MAX ] ;
int cap [ MAX ] [ MAX ] ;
int flux [ MAX ] [ MAX ] , tata [ MAX ] ;

bitset < MAX > viz ;

queue < int > Q ;

int n ;

int S , D ;

inline int bfs ( )
{
    viz.reset ( ) ;
    Q.push ( S ) ;

    while ( !Q.empty ( ) )
    {
        int nod = Q.front ( ) ;
        Q.pop ( ) ;
        if ( nod == D ) continue ;
        for ( auto x : gr [ nod ] )
        {
            if ( cap [ nod ] [ x ] == flux [ nod ] [ x ] or viz [ x ] ) continue ;
            Q.push ( x ) ;
            tata [ x ] = nod ;
            viz [ x ] = 1 ;
        }
    }

    return viz [ D ] ;
}

int main ( void )
{
    int t ;
    cin >> t ;
    while ( t -- ) {
        int m ;
        cin >> n >> m ;
        FORN ( i , 1 , n ) {
            int x ;
            cin >> x ;
            gr [ 0 ].pb ( i )  ;
            gr [ i ].pb ( 0 )  ;
            cap [ 0 ] [ i ] = x ;
        }
        FORN ( un , 1 , m ) {
            int cate ;
            int maxt ;
            cin >> cate ;
            cin >> maxt ;
            while ( cate -- ) {
                int x ;
                cin >> x ;
                gr [ x ].pb ( n + un ) ;
                gr [ n + un ].pb ( x ) ;
                cap [ x ] [ n + un ] = 1 << 30 ;
            }
            gr [ n + un ].pb ( n + m + 1 ) ;
            gr [ n + m + 1 ].pb ( n + un ) ;
            cap [ n + un ] [ n + m + 1 ] = maxt ;
        }
        int CET = 0 ;
        S = 0 ;
        D = n + m + 1 ;
        for ( CET = 0 ; bfs ( ) ; )
        {
            for ( auto x : gr [ D ] )
            {
                if ( cap [ x ] [ D ] == flux [ x ] [ D ] or !viz [ x ] ) continue ;
                tata [ D ] = x ;

                int local = 1 << 30 ;

                for ( int i = D ; i != S ; i = tata [ i ] )
                {
                    local = min ( local , cap [ tata [ i ] ] [ i ] - flux [ tata [ i ] ] [ i ] ) ;
                }

                if ( local == 0 ) continue ;

                for ( int i = D ; i != S ; i = tata [ i ] )
                {
                    flux [ tata [ i ] ] [ i ] += local ;
                    flux [ i ] [ tata [ i ] ] -= local ;
                }

                CET += local ;
            }
        }
        cout << CET << '\n' ;
        FORN ( i , S , D ) {
            gr [ i ].clear ( ) ;
            tata [ i ] = 0 ;
            FORN ( j , i , D ) {
                cap [ i ] [ j ] = cap [ j ] [ i ] = 0 ;
                flux [ i ] [ j ] = flux [ j ] [ i ] = 0 ;
            }
        }
    }
    return 0;
}