#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>

using namespace std;

#define maxn 50011
#define INF -10000000


struct Node {
	long long son;
	long long w;
};

long long ans;
vector<Node> num[maxn];
long long d[maxn][2];

void DFS(long long x,long long p)
 

{
	long long i,v;
	d[x][0]=d[x][1]=INF;
	for(i=0;i<num[x].size();i++)
	{
		v=num[x][i].son;
		if(v!=p)
		{
			DFS(v,x);
			if(d[v][0]>0)
			{
				if(d[x][0]<num[x][i].w+d[v][0])
				{
					d[x][1]=d[x][0];
					d[x][0]=num[x][i].w+d[v][0];
				}
				else if(d[x][1]<num[x][i].w+d[v][0])
					d[x][1
 
]=num[x][i].w+d[v][0];
			}
			else
			{
				if(d[x][0]<num[x][i].w)
				{
					d[x][1]=d[x][0];
					d[x][0]=num[x][i].w;
				}
				else if(d[x][1]<num[x][i].w)
					d[x][1]=num[x][i].w;
			}

			
		}
	}
	ans=max(ans,d[x][0]);
	ans=max(ans,d[x][0]+d[x][1]);
}

int main()
{
	long long N,M;
	long long
 
 i,u,v;
	long long w;
	Node tmp;

	while(scanf("%lld%lld",&N,&M)==2)
	{
		for(i=1;i<=N;i++)
			num[i].clear();

		ans=-10000000;
		for(i=1;i<=M;i++)
		{
			scanf("%lld%lld%lld",&u,&v,&w);
			tmp.w=w;
			tmp.son=v;	num[u].push_back(tmp);
			tmp.son=u;	num[v].push_back(tmp);
			ans=max(ans,w);
		}

		DFS(1,-1);
		printf("%lld\n",ans);
	}

	return 0;
}
/**********************************************************************
	Problem: 1317
	User: 3901140225
	Language: C++
	Result: AC
	Time:104 ms
	Memory:5900 kb
**********************************************************************/

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
//點標 [0,n]
typedef long long ll;
const int N = 3010;
const int M = 500010;
const ll INF = 1e18;
template<class T>
struct Max_Flow {
    int n;
    int Q[N], sign;
    int head[N], level[N], cur[N], pre[N];
    int nxt[M], pnt[M], E;
    T cap[M];
    void Init(int n) {
        this->n = n+1;
        E = 0;
        std::fill(head, head + this->n, -1);
    }
    //有向rw 就= 0
    void add(int from, int to, T c, T rw) {
        pnt[E] = to;
        cap[E] = c;
        nxt[E] = head[from];
        head[from] = E++;

        pnt[E] = from;
        cap[E] = rw;
        nxt[E] = head[to];
        head[to] = E++;
    }
    bool Bfs(int s, int t) {
        sign = t;
        std::fill(level, level + n, -1);
        int *front = Q, *tail = Q;
        *tail++ = t; level[t] = 0;
        while(front < tail && level[s] == -1) {
            int u = *front++;
            for(int e = head[u]; e != -1; e = nxt[e]) {
                if(cap[e ^ 1] > 0 && level[pnt[e]] < 0) {
                    level[pnt[e]] = level[u] + 1;
                    *tail ++ = pnt[e];
                }
            }
        }
        return level[s] != -1;
    }
    void Push(int t, T &flow) {
        T mi = INF;
        int p = pre[t];
        for(int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
            mi = std::min(mi, cap[p]);
        }
        for(int p = pre[t]; p != -1; p = pre[pnt[p ^ 1]]) {
            cap[p] -= mi;
            if(!cap[p]) {
                sign = pnt[p ^ 1];
            }
            cap[p ^ 1] += mi;
        }
        flow += mi;
    }
    void Dfs(int u, int t, T &flow) {
        if(u == t) {
            Push(t, flow);
            return ;
        }
        for(int &e = cur[u]; e != -1; e = nxt[e]) {
            if(cap[e] > 0 && level[u] - 1 == level[pnt[e]]) {
                pre[pnt[e]] = e;
                Dfs(pnt[e], t, flow);
                if(level[sign] > level[u]) {
                    return ;
                }
                sign = t;
            }
        }
    }
    T Dinic(int s, int t) {
        pre[s] = -1;
        T flow = 0;
        while(Bfs(s, t)) {
            std::copy(head, head + n, cur);
            Dfs(s, t, flow);
        }
        return flow;
    }
};
Max_Flow <ll>F;

ll dream[N], work[N], ans;
int from, to;
int n, m;
const ll C = 1e6;
void input(){
	ans = 0;
	from = 0; to = n+m+1;
	F.Init(to);
	for(int i = 1; i <= n; i++)
	{
		scanf("%lld", &dream[i]);
		F.add(from, i, dream[i]*C+1LL, 0);
		ans += dream[i];
	}
	for(int i = 1; i <= m; i++)
	{
		scanf("%lld", &work[i]);
		if(work[i] >= 0) ans += work[i];
		else
			F.add(n +i, to, -work[i]*C, 0);
	}
	for(int i = 1, siz, u; i <= n; i++)
	{
		scanf("%d", &siz);
		while(siz--){
			scanf("%d", &u);
			if(work[u] >= 0)continue;
			F.add(i, n+u, INF, 0);
		}
	}
}
int main() {
	while(~scanf("%d %d", &n, &m)){
		input();
		ll flow = F.Dinic(from,to);
	//	cout<<"FLOW:"<<flow<<endl;
		cout<< ans - flow / C << " " << n-flow % C <<endl;
	}
	return 0;
}
/**********************************************************************
	Problem: 1319
	User: 3901140225
	Language: C++
	Result: AC
	Time:200 ms
	Memory:9940 kb
**********************************************************************/

#include <iostream>
#include <cstring>
#include <cstdio>
#define MAXN 1010
#define MAXM 10100
#define INF 0x3f3f3f3f
using namespace std;

int n, m;
int dis[MAXN], vis[MAXN], map[MAXN][MAXN], cost[MAXN], total[MAXN];

int dijkstra()
{
    for(int i = 2; i <= n; i++)
        dis[i] = map[1][i];
    vis[1] = 1;
    dis[1] = 0;
    total[1] = cost[1];
    for(int i = 2; i <= n; i++)
        total[i] = cost[i] + cost[1];
    for(int i = 2; i <= n; i++)
    {
        int k = -1, minx = INF;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && dis[j] < minx)
            {
                minx = dis[j];
                k = j;
            }
        }
        if(k == -1) break;
        vis[k] = 1;
        for(int j = 1; j <= n; j++)
        {
            if(vis[j]) continue;
            if(dis[j] > dis[k] + map[k][j])
            {
                dis[j] = dis[k] + map[k][j];
                total[j] = total[k] + cost[j];
            }
            else if(dis[j] == dis[k] + map[k][j])
            {
                if(total[j] < total[k] + cost[j])
                    total[j] = total[k] + cost[j];
            }
        }
    }
    return dis[n];
}

int main()
{
    int a, b, c;
    while(scanf("%d%d", &n, &m) != EOF)
    {
        memset(vis, 0, sizeof(vis));
        memset(map, 0x3f, sizeof(map));
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &cost[i]);
            map[i][i] = 0;
        }
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &a, &b, &c);
            if(c < map[a][b])
                map[a][b] = map[b][a] = c;
        }
        int ans = dijkstra();
        if(ans == INF) printf("-1\n");
        else printf("%d\n", total[n]);
    }
    return 0;
}
/**********************************************************************
	Problem: 1321
	User: 3901140225
	Language: C++
	Result: AC
	Time:412 ms
	Memory:6024 kb
**********************************************************************/