#include<stdio.h>
#include<iostream>
#include<queue>
#include<climits>
using namespace std;
const int MAXV=210;
const int MAXDEGREE=40005;
const int INF=INT_MAX ;
int dis[MAXV];
typedef struct 
{
	int v;    //顶点编号
	int capacity;  //容量
	int flow;   //流量
	int residual;   //剩余容量
}edge;
typedef struct
{
	edge edge[MAXV+1][MAXV+1];   
	int degree[MAXV+1];   
	int nvertices;/// 顶点数
	int nedges;  //边数目
}graph;
void init(graph *g)
{    
	int i;
    
	for(i=0;i<=g->nvertices;i++)
	{
		g->degree[i]=0;   // 所有的度数初始化为0
	}
	
	return ;
}
edge *findedge(graph *g,int s,int e)   //判断是否有重边
{
	int i;///edge *tep;
	for(i=0;i<g->degree[s];i++)
		if(g->edge[s][i].v==e)
			return &g->edge[s][i]; 
		return NULL;
}

void insertArc(graph *g,int s,int e,int w)   
{ 
	int k;
	edge *tem;
	tem=findedge(g,s,e);
	k=g->degree[s];
	if(tem==NULL)     //判断是否有重边   无重边
	{ 
		g->edge[s][k].v=e;
		g->edge[s][k].capacity=w;
		g->edge[s][k].flow=0;///
		g->edge[s][k].residual=w;
		g->degree[s]++;
	}
	else
	{                        //有重边
		tem->capacity+=w;
		tem->residual+=w;
	}
	
	return ;
	
}

int Min(int m,int n)     //找出最小增流量
{
	if(m>n)return n;
	else
		return m;
	
}
int bfs(graph *g,int s,int e)    //广度收索 分层
{ 
	if(s==e)return 0;
	int k,i,tmp;
	for(i=0;i<=g->nvertices;i++)
		dis[i]=-1;
	dis[s]=0;
	queue<int>q;
	q.push(s);
	while(!q.empty())
	{
		k=q.front();
		q.pop();
		for(i=0;i<g->degree[k];i++)
		{
			tmp=g->edge[k][i].v;
			if(dis[tmp]==-1 && g->edge[k][i].residual!=0)
			{
				dis[tmp]=dis[k]+1;
				if(tmp==e)
					return  1;  
				q.push(tmp);
			}
		}
		
	}
	return 0;
}


int dfs(graph *g,int s,int e,int limit)  ///深度  求出最小增加的流量
{
	int volume=0,k,i;
	if(s==e)return limit;
	edge *tmp;
	for(i=0;i<g->degree[s];i++)
	{
        tmp=&g->edge[s][i];
		if(tmp->residual!=0 && dis[tmp->v]==dis[s]+1)
		{
			k=dfs(g,tmp->v,e,Min(tmp->residual,limit-volume));
			if(k>0)
			{
				tmp->flow+=k;
				tmp->residual-=k;
				// tmp=findedge(g,tmp->v,s);
				//  tmp->residual+=k;
				volume+=k;  
				if(volume==limit)break;
			}
			else
				dis[tmp->v]=-1;
		}
		
		
	}
	return volume;
}
int Dinic(graph *g,int s,int e)   //
{
	int maxFlow=0;
	while(bfs(g,s,e))
	{
		maxFlow+=dfs(g,s,e,INF);
	}
	return maxFlow;
}
int main()
{  
	graph *g;
    int m,n,a[1000],flag[1001],x,y,i,t,w,maxFlow,b[1000];
	while(scanf("%d%d",&m,&n)!=EOF){
        int s=1;
		memset(flag,0,sizeof(flag));
		
		memset(b,0,sizeof(b));
		
		g=(graph *)malloc(sizeof(graph));
		g->nvertices=n+3;
		init(g);
		t=n+2;
		for(i=1;i<=m;i++)
			scanf("%d",&a[i]);
		for(int k=1;k<=n;k++)
		{
			//insertArc(g,s,k+1,a[i]);
			scanf("%d",&x);
			
			for(i=1;i<=x;i++)
			{
				
				scanf("%d",&y);
				
				b[k]=b[k]+a[y];
				a[y]=0;
				if(flag[y]!=0)
				{
					insertArc(g,flag[y]+1,k+1,1005);
					
				}
				else
					
					flag[y]=k;
			}
			if(b[k]!=0)
			  insertArc(g,s,k+1,b[k]);
			
			scanf("%d",&w);
			
			insertArc(g,k+1,t,w);
			
		}
		
		
		maxFlow=Dinic(g,s,t);
		cout<<maxFlow<<endl;
		
		
		free(g);
	}
	return 0;
}