#include <stdio.h>
#include <string.h>

#include <vector>
#include <map>
using namespace std;

#define NMAX 501
#define KMAX 10
#define MMAX 501
#define MAX_STATES 4150
#define INF 666666666

struct tree_node {
	vector<int> *nodes;
	map<int, int> *isInside;
	int nstates;
	int nupnodes;
	int nupstates;
	char state[MAX_STATES][KMAX];
	int smin[MAX_STATES];
	char upstate[MAX_STATES][KMAX];
	int sextra[MAX_STATES];
	map<int, int> *sextraMap;
};

struct tree_node tnode[NMAX];
vector<int> nodes[NMAX], edge[NMAX];
map<int, int> isInside[NMAX], sextraMap[NMAX];
int A[MMAX][MMAX];
char Asellocal[MMAX][MMAX];
char s[KMAX], used[KMAX], viz[NMAX], maxcols;
//int state[KMAX][MAX_STATES][KMAX];
//int smins[KMAX][MAX_STATES][KMAX];
int i, j, k, p, q, N, M, P, localmax;

void readInputData(void)
{
	freopen("tproc.in", "r", stdin);

	scanf("%d %d %d", &N, &M, &maxcols);

	for (i = 1; i <= N; i++)
		edge[i].clear();

	for (k = 1; k < N; k++)
	{
		scanf("%d %d", &i, &j);

		edge[i].push_back(j);
		edge[j].push_back(i);
	}

	for (k = 1; k <= N; k++)
	{
		tnode[k].nodes = &(nodes[k]);
		tnode[k].nodes->clear();

		tnode[k].isInside = &(isInside[k]);
		tnode[k].isInside->clear();

		tnode[k].sextraMap = &(sextraMap[k]);
		tnode[k].sextraMap->clear();

		scanf("%d", &p);

		for (i = 1; i <= p; i++)
		{
			scanf("%d", &j);

			tnode[k].nodes->push_back(j);
		}
	}

	memset(A, 0, sizeof(A));

	scanf("%d", &P);

	for (k = 1; k <= P; k++)
	{
		scanf("%d %d %d", &i, &j, &q);
		A[i][j] = A[j][i] = q;
	}
}

void genStates(char niv, char cmax, int n)
{
	char i;

	if (niv >= tnode[n].nodes->size())
	{
		tnode[n].nstates++;
		memcpy(tnode[n].state[tnode[n].nstates], s, sizeof(s));
		tnode[n].smin[tnode[n].nstates] = 0;

		for (j = 0; j < tnode[n].nodes->size(); j++)
			for (k = j + 1; k < tnode[n].nodes->size(); k++)
				if (s[j] == s[k])
				{
					p = (*tnode[n].nodes)[j];
					q = (*tnode[n].nodes)[k];

					tnode[n].smin[tnode[n].nstates] += A[p][q];
				}
	}
	else
	{
		for (i = 1; i <= cmax + 1 && i <= maxcols; i++)
		{
			s[niv] = i;

			if (i > cmax)
				genStates(niv + 1, cmax + 1, n);
			else
				genStates(niv + 1, cmax, n);
		}
	}
}

char* normalize(char *s, int K)
{
	char i, cnt = 0;

	memset(used, 0, sizeof(used));

	for (i = 0; i < K; i++)
	{
		if (!used[s[i]])
			used[s[i]] = ++cnt;

		s[i] = used[s[i]];
	}

	return s;
}

int hash(char *s, int K)
{
	int i, h = 0;

	for (i = 0; i < K; i++)
		h = (h << 3) + (s[i] - 1);

	return h;
}

inline int getsextra(int n, char* s)
{
	int stnum = (*(tnode[n].sextraMap))[hash(s, tnode[n].nupnodes)];
	return tnode[n].sextra[stnum];
}

// n = nodul din arbore
// t = parintele lui n (in arbore)
void computeCols(int n, int t)
{
	int x, y, p, q, inp, inq, nextra, nextra2, cmax, eq, st, localmin;

	viz[n] = 1;

	// reordoneaza nodurile grafului din cadrul nodului curent al arborelui
	// (primele vor fi nodurile care apar si in cadrul parintelui nodului curent)
	for (x = 0; x < tnode[n].nodes->size(); x++)
		for (y = x + 1; y < tnode[n].nodes->size(); y++)
		{
			p = (*tnode[n].nodes)[x];
			q = (*tnode[n].nodes)[y];

			if ((*tnode[t].isInside)[p])
				inp = 1;
			else
				inp = 0;

			if ((*tnode[t].isInside)[q])
				inq = 1;
			else
				inq = 0;

			if ((!inp && inq) || (inp == inq && p > q))
			{
				(*tnode[n].nodes)[x] = q;
				(*tnode[n].nodes)[y] = p;
			}
		}

	tnode[n].nupnodes = 0;

	for (x = 0; x < tnode[n].nodes->size(); x++)
	{
		p = (*tnode[n].nodes)[x];
		(*tnode[n].isInside)[p] = x + 1;

		if ((*tnode[t].isInside)[p])
			tnode[n].nupnodes++;
	}

	// genereaza toate colorarile posibile cu nodurile grafului din nodul curent al arborelui
	tnode[n].nstates = 0;	
	genStates(0, 0, n);

	localmin = INF;

	for (x = 1; x <= tnode[n].nstates; x++)
	{
		tnode[n].sextra[x] = 0;

		if (tnode[n].smin[x] < localmin)
			localmin = tnode[n].smin[x],
			st = x;
	}

	// selecteaza muchiile ce trebuie adunate in contul lui 'localmin'
	for (x = 0; x < tnode[n].nodes->size(); x++)
		for (y = x + 1; y < tnode[n].nodes->size(); y++)
			if (tnode[n].state[st][x] == tnode[n].state[st][y])
			{
				p = (*tnode[n].nodes)[x];
				q = (*tnode[n].nodes)[y];

				Asellocal[p][q] = Asellocal[q][p] = 1; 
			}

	// adauga la starile generate contributia fiilor nodului curent din arbore

	for (x = 0; x < edge[n].size(); x++)
	{
		y = edge[n][x];

		if (!viz[y])
		{
			computeCols(y, n);

			for (st = 1; st <= tnode[n].nstates; st++)
				if (tnode[n].smin[st] < INF)
				{
					memset(used, 0, sizeof(used));

					for (p = 0; p < tnode[y].nupnodes; p++)
					{
						q = (*tnode[y].nodes)[p];
						q = (*tnode[n].isInside)[q] - 1;
						used[tnode[n].state[st][q]] = 1;
						s[p] = tnode[n].state[st][q];
					}

					nextra = getsextra(y, normalize(s, tnode[y].nupnodes));
					tnode[n].sextra[st] += nextra;
				}
		}
	}

	for (st = 1; st <= tnode[n].nstates; st++)
		if (tnode[n].smin[st] < INF)
		{
			if (tnode[n].sextra[st] < INF)
				tnode[n].smin[st] += tnode[n].sextra[st];
			else
				tnode[n].smin[st] = INF;

			/*
			if (tnode[n].sextra[st] > 0 && tnode[n].sextra[st] < INF)
				printf("!!! nod=%d, st=%d, supl cols=%d\n", n, st, tnode[n].sextra[st]);
			*/

			tnode[n].sextra[st] = 0;
		}

	// pastreaza doar prefixele de 'nupnodes' noduri
	tnode[n].nupstates = 0;

	for (x = 1; x <= tnode[n].nstates; x++)
	{
		memcpy(s, tnode[n].state[x], sizeof(s));
		nextra = tnode[n].smin[x];

		if (tnode[n].smin[x] >= INF)
			nextra = INF;
		else
		{
			for (p = 0; p < tnode[n].nupnodes; p++)
				for (q = p + 1; q < tnode[n].nupnodes; q++)
					if (tnode[n].state[x][p] == tnode[n].state[x][q])
						nextra -= A[(*tnode[n].nodes)[p]][(*tnode[n].nodes)[q]];
		}

		if (tnode[n].nupstates == 0)
		{
			tnode[n].nupstates = 1;
			memcpy(tnode[n].upstate[1], s, sizeof(s));
			tnode[n].sextra[1] = nextra;
		}
		else
		{
			for (eq = 1, y = 0; y < tnode[n].nupnodes; y++)
				if (s[y] != tnode[n].upstate[tnode[n].nupstates][y])
				{
					eq = 0;
					break;
				}

			if (eq)
			{
				if (nextra < tnode[n].sextra[tnode[n].nupstates])
					tnode[n].sextra[tnode[n].nupstates] = nextra;
			}
			else
			{
				tnode[n].nupstates++;
				memcpy(tnode[n].upstate[tnode[n].nupstates], s, sizeof(s));
				tnode[n].sextra[tnode[n].nupstates] = nextra;
			}
		}
	}

	for (x = 1; x <= tnode[n].nupstates; x++)
		(*(tnode[n].sextraMap))[hash(tnode[n].upstate[x], tnode[n].nupnodes)] = x;

	// afisaza niste informatii pentru debug

	/*
	printf("### nod=%d [tata=%d]\n", n, t);
	printf("nnodes=%d, nstates=%d\n", tnode[n].nodes->size(), tnode[n].nstates);
	printf("localmin=%d\n", localmin);
	printf("nupnodes=%d, nupstates=%d\n", tnode[n].nupnodes, tnode[n].nupstates);

	printf("nodes:");
	for (x = 0; x < tnode[n].nodes->size(); x++)
		printf(" %d", (*(tnode[n].nodes))[x]);
	printf("\n");

	printf("|states|\n");
	for (st = 1; st <= tnode[n].nstates; st++)
	{
		if (tnode[n].smins[st] >= INF)
			continue;

		printf("-> state=%d:", st);
		for (p = 0; p < tnode[n].nodes->size(); p++)
			printf(" %d", tnode[n].state[st][p]);

		printf(" : smins=%d\n", tnode[n].smin[st]);
	}

	printf("|upstates|\n");
	for (st = 1; st <= tnode[n].nupstates; st++)
	{
		if (tnode[n].sextra[st] >= INF)
			continue;

		printf("-> upstate=%d:", st);
		for (p = 0; p < tnode[n].nupnodes; p++)
			printf(" %d", tnode[n].upstate[st][p]);
		printf(" : hash=%d, sextra=%d\n", hash(tnode[n].upstate[st], tnode[n].nupnodes), tnode[n].sextra[st]);
	}
	*/
}

void writeOutputData(void)
{
	int smin;

	localmax = 0;

	for (i = 1; i < M; i++)
		for (j = i + 1; j <= M; j++)
			if (Asellocal[i][j])
				localmax += A[i][j];

	printf("* local_smin=%d\n", localmax);

	smin = INF;

	for (i = 1; i <= tnode[1].nstates; i++)
		if (tnode[1].smin[i] < smin)
			smin = tnode[1].smin[i];

	printf("* global_smin=%d\n", smin);

	freopen("tproc.out", "w", stdout);
	printf("%d\n", smin);
}

int main()
{
	readInputData();

	localmax = 0;
	memset(viz, 0, sizeof(viz));
	memset(Asellocal, 0, sizeof(Asellocal));
	computeCols(1, 1);

	writeOutputData();

	return 0;
}