#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; 
}