#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;
const int VMAX = 4200;
const int NMAX = 512;
const int KMAX = 8;
const int INF = 0x3f3f3f3f;
#define FORI(p, X) for (typeof((X).begin()) p = (X).begin(); p != (X).end(); ++p)
#define PB push_back
int N, M, K, P, NP;
int INC[NMAX][NMAX], SAT[NMAX];
vector <int> G[NMAX], T[NMAX], PERM[VMAX];
int used[KMAX], D[NMAX][VMAX], BUF[NMAX][VMAX];
int jump[KMAX][KMAX][VMAX];
void read(void) {
ifstream fin("tproc.in");
int i, j, u, v, c, cnt;
fin >> M >> N >> K;
for (i = 1; i < M; ++i) {
fin >> u >> v;
G[u].PB(v); G[v].PB(u);
}
for (i = 1; i <= M; ++i) {
fin >> cnt;
T[i].resize(cnt);
for (j = 0; j < cnt; ++j)
fin >> T[i][j];
}
fin >> P;
for (i = 0; i < P; ++i) {
fin >> u >> v >> c;
INC[u][v] = INC[v][u] = c;
}
fin.close();
}
void DFS(int k, int t) {
FORI(p, G[k])
if (*p != t)
DFS(*p, k);
if (t) {
int d = 0;
FORI(p, T[k]) {
FORI(q, T[t])
if (*p == *q) {
swap(*p, T[k][d++]);
break;
}
}
SAT[k] = d;
}
}
void back(vector <int> V, int k) {
if ((int) V.size() == KMAX) {
PERM[NP++] = V;
} else {
int i;
V.PB(0);
for (i = 0; i <= k && i < K; ++i)
*V.rbegin() = i,
back(V, max(k, i+1));
}
}
int solve(int, int, int);
inline void complete(int k, int v, int &ans, int pos, int call, int tata) {
int i;
if (k == (int) T[call].size()) {
ans = min(ans, solve(call, pos, tata));
} else {
for (i = 0; i <= v && i < K; ++i)
complete(k+1, max(v, i+1), ans, jump[k][i][pos], call, tata);
}
}
int solve(int gr, int op, int tata) {
if (D[gr][op] != -1)
return D[gr][op];
int i, j, u, cost = 0;
for (i = 0; i < (int) T[gr].size(); ++i)
for (j = max(i+1, SAT[gr]); j < (int) T[gr].size(); ++j)
if (PERM[op][i] == PERM[op][j])
cost += INC[ T[gr][i] ][ T[gr][j] ];
FORI(p, G[gr]) {
if (*p == tata) continue;
memset(used, 0xff, sizeof(used));
int cnt = 0, ans = INF, pos = 0, v;
for (i = 0; i < SAT[*p]; ++i) {
for (j = 0; T[gr][j] != T[*p][i]; ++j);
u = PERM[op][j];
v = ( (used[u] == -1 ? (used[u] = cnt++) : used[u]) );
pos = jump[i][v][pos];
}
if (BUF[*p][pos] == -1) {
complete(SAT[*p], cnt, ans, pos, *p, gr);
BUF[*p][pos] = ans;
}
cost += BUF[*p][pos];
}
return D[gr][op] = cost;
}
void write(void) {
ofstream fout("tproc.out");
fout << D[0][0] << '\n';
fout.close();
}
void prep(vector <int> V, int p, int k) {
if ((int) V.size() == KMAX) return;
int i, q;
V.PB(0);
for (i = 0; i <= k && i < K; ++i) {
*V.rbegin() = i;
q = lower_bound(PERM + p, PERM + NP, V) - PERM;
jump[V.size() - 1][i][p] = q;
prep(V, q, max(k, i+1));
}
}
int main(void) {
read();
DFS(1, 0);
back(vector <int> (), 0);
prep(vector <int> (), 0, 0);
memset(D, 0xff, sizeof(D));
memset(BUF, 0xff, sizeof(BUF));
G[0].PB(1);
solve(0, 0, 0);
write();
return 0;
}