/*
TASK:food
LANG:C++
*/

    #include <iostream>
    #include <algorithm>
    #include <vector>
    #define MAXN 101
    using namespace std;
    
    long c[MAXN], prc[MAXN], prn[MAXN], edge[MAXN],
         effect[MAXN], Q[MAXN], last = 0, g[MAXN][MAXN], N, M;
    bool used[MAXN];
    vector<long> pri[MAXN];
    
    void read_inp()
    {
         
         int i, j;
         long tmp_pri;
         cin >> N >> M;
         for( i = 1; i <= N; i++ ) cin >> c[i];
         for( i = 0; i < M; i++ )
         {
              cin >> prc[i];                        //Promotion cost
              cin >> prn[i];                        //Number of items in Pr.
              for( j = 0; j < prn[i]; j++ ) 
              {
                   cin >> tmp_pri;
                   pri[i].push_back(tmp_pri);
              }                                     //Prom. items
              sort( pri[i].begin(), pri[i].end() );
         }     
    }

    void calc_g()
    {
         int i, j, k, l;
         
         for( i = 0; i < M; i++ )
              for( j = i; j < M; j++ )
              {
                   g[i][j] = 0;
                   if( i == j ) continue;
                   for( k = 0, l = 0; k < prn[i] && l < prn[j];)
                   {
                        if( pri[i][k] < pri[j][l] ) k++;
                        if( pri[i][k] > pri[j][l] ) l++;
                        if( pri[i][k] == pri[j][l] )
                        {
                            g[i][j] -= c[ pri[i][k] ];
                            g[j][i] -= c[ pri[i][k] ];
                            k++;
                            l++;
                        }
                   }
              }
    }
    
    void calc_edge()    //needs read_inp
    {
         int i, j;
         for( i = 0; i < M; i++ )
         {
              used[i] = 1;                //a bit of out-of-place init
              
              edge[i] = 0 - prc[i];
              for( j = 0; j < prn[i]; j++ )
                   edge[i] += c[ pri[i][j] ];
         }
    }
    
    void calc_effect()     //needs calc_edge, calc_g
    {
         int i, j;
         
         for( i = 0; i < M; i++ )
         {
              effect[i] = edge[i];
              for( j = 0; j < M; j++ )
              effect[i] += g[i][j];
         }
    }
    
    void rem_Q()
    {
         int i, j, x;
         for( i = 0; i < last; i++ )
         {
              x = Q[i];
              used[x] = 0;
              for( j = 0; j < M; j++ )
              {
                   if( !used[j] ) continue;
                   effect[j] -= g[x][j];
                   g[x][j] = 0;
                   g[j][x] = 0;
              }
         }
         last = 0;
    }
    
    void rem_positive()
    {
         bool finished = 0;
         int i;
         
         
         while( !finished )
         {
                finished = 1;
                for( i = 0; i < M; i++ )
                {
                     if( !used[i] ) continue;
                     if( effect[i] >= 0 )
                     {
                         Q[last++] = i;
                         finished = 0;
                     }
                }
                if( !finished ) rem_Q();
         }
    }
    
    void print_rest()
    {
         int i, j;
         long result = 0;
         for( i = 0; i < M; i++ )
         {
              if( used[i] )
              {
                  result += edge[i];
                  for( j = i+1; j < M; j++ )
                       if( used[j] ) 
                           result += g[i][j];
              }
         }
         cout << 0 - result << endl;         
    }
    
    int main()
    {
        read_inp();
        calc_g();
        calc_edge();
        calc_effect();
        
        rem_positive();
        print_rest();

        return 0;
    }
