#include <bits/stdc++.h>
using namespace std;

#pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
// Ofast, O0, O1, O2, O3, unroll-loops, fast-math, trapv

typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;

#define Mp          make_pair
#define sep         ' '
#define endl        '\n'
#define F	        first
#define S	        second
#define pb          push_back
#define SZ(x)       (int)x.size()
#define all(x)      (x).begin(),(x).end()
#define kill(res)	cout << res << '\n', exit(0);
#define set_dec(x)	cout << fixed << setprecision(x);
#define fast_io     ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io     freopen("input.txt", "r", stdin) ; freopen("output.txt", "w", stdout);

#define lid (id*2)
#define rid (id*2+1)
#define mid ((l+r)/2)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const ll L = 20;
const ll N = 1e5 + 50;
const ll inf = 1e18;

ll n, m, q, red[N], h[N], dist[N], st[N], ft[N], timer, anc[N], par[N][L];

vector<pii> adj[N];

void dfs(int v, int p = 0){
    if(red[v]) anc[v] = v;
    else anc[v] = anc[p];

    par[v][0] = p;
    for(int i = 1; i < L; i++){
        par[v][i] = par[par[v][i-1]][i-1];
    }

    st[v] = timer++;
    for(auto [u, w]: adj[v]){
        if(u == p) continue;
        h[u] = h[v] + w;
        dist[u] = dist[v] + 1;
        dfs(u, v);
    }
    ft[v] = timer;
}

int getPar(int v, int k){
    for(int i = 0; i < L; i++) if(k >> i & 1) v = par[v][i];
    return v;
}

int lca(int u, int v){
    if(dist[u] > dist[v]) swap(u, v);
    v = getPar(v, dist[v] - dist[u]);
    if(u == v) return v;

    for(int i = L-1; i >= 0; i--){
        if(par[v][i] != par[u][i]){
            v = par[v][i]; u = par[u][i];
        }
    }
    return par[v][0];
}

vector<pll> g[N];
vector<int> child[N];

ll seg[3][N*4], res;

void upd(int i, int x, ll y, int l = 0, int r = n, int id = 1){
    if(l+1 == r){
        seg[i][id] = y; return;
    }
    if(x < mid) upd(i, x, y, l, mid, lid);
    else upd(i, x, y, mid, r, rid);
    seg[i][id] = max(seg[i][lid], seg[i][rid]);
}

ll get(int i, int ql, int qr, int l = 0, int r = n, int id = 1){
    if(ql <= l && r <= qr) return seg[i][id];
    if(qr <= l || r <= ql) return -inf;
    return max(get(i, ql, qr, l, mid, lid), get(i, ql, qr, mid, r, rid));
}

void calc(int v){
    for(int u: child[v]){
        upd(1, st[u], h[u]); 
        upd(2, st[u], -inf);
    }
    ll th = max(max(get(2, st[v], ft[v]), get(1, st[v], ft[v]) - h[v]), max(get(0, 0, st[v]), get(0, ft[v], n)));
    //cout << v << sep << th << sep << get(2, st[v], ft[v]) << sep << get(1, st[v], ft[v]) - h[v] << sep << get(0, 0, st[v]) << sep << get(0, ft[v], n) << endl;
    res = min(res, th);

    for(auto [u, w]: g[v]) calc(u);
    for(int u: child[v]){
        upd(1, st[u], -inf); 
        upd(2, st[u], h[u] - h[anc[u]]);
    }
}

void Main(){
    cin >> n >> m >> q;

    for(int i = 1; i <= m; i++){
        int x; cin >> x; red[x] = 1;
    }

    for(int i = 1; i < n; i++){
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].pb({v, w});
        adj[v].pb({u, w});
    }

    timer = 0; dfs(1);

    for(int i = 0; i < 3; i++) for(int j = 0; j < n; j++) upd(i, j, -inf);

    for(int i = 1; i <= q; i++){
        int k;
        cin >> k;

        vector<int> vec, imp;
        for(int j = 1; j <= k; j++){
            int x; cin >> x; 
            imp.pb(x);
            vec.pb(x); vec.pb(anc[x]); 
            child[anc[x]].pb(x);
        }

        sort(all(vec), [&](int i, int j){return st[i] < st[j];});

        vector<int> vc;
        for(int j = 0; j < SZ(vec) - 1; j++){
            vc.pb(vec[j]); vc.pb(lca(vec[j], vec[j+1]));
        }
        vc.pb(vec.back());

        sort(all(vc), [&](int i, int j){return st[i] < st[j];});
        vc.resize(unique(all(vc)) - vc.begin());

        vec = vc;

        vector<int> sta;
        while(!vc.empty()){
            int v = vc.back(); vc.pop_back();
            while(!sta.empty() && ft[sta.back()] <= ft[v]){
                g[v].pb({sta.back(), h[v] - h[sta.back()]});
                sta.pop_back();
            }
            sta.pb(v);
        }
        int root = sta.back();

        for(int j: imp){
            upd(0, st[j], h[j] - h[anc[j]]);
            upd(2, st[j], h[j] - h[anc[j]]);
        }

        res = inf; calc(root);

        cout << res << endl;

        for(int j: vec){
            child[j].clear(); g[j].clear();
            upd(0, st[j], -inf);
            upd(2, st[j], -inf);
        }
    }

    for(int i = 1; i <= n; i++){
        adj[i].clear(); red[i] = 0;
    }
}

int main(){
    fast_io;
    
    int T;
    cin >> T;

    while(T--){
        Main();
    }

}