#include <bits/stdc++.h>
#define MAXN ((int) 1e5)
#define MAXP 20
using namespace std;

int n, m, q;
bool flag[MAXN + 10];

vector<int> e[MAXN + 10], v[MAXN + 10];
// dis[i]：从根到节点 i 的距离
// cost[i]：不加入新红点时，节点 i 的代价
long long dis[MAXN + 10], cost[MAXN + 10];
// 在 dfs 序列上维护 rmq 求 lca
int clk, bgn[MAXN + 10];
int lg[MAXN * 2 + 10], f[MAXP][MAXN * 2 + 10];

void dfs(int sn, int fa) {
    f[0][++clk] = sn; bgn[sn] = clk;

    for (int i = 0; i < e[sn].size(); i++) {
        int fn = e[sn][i];
        if (fn == fa) continue;

        dis[fn] = dis[sn] + v[sn][i];
        if (flag[fn]) cost[fn] = 0;
        else cost[fn] = cost[sn] + v[sn][i];

        dfs(fn, sn);
        f[0][++clk] = sn;
    }
}

// rmq 预处理
void preLca() {
    for (int p = 1; p < MAXP; p++) 
        for (int i = 1; i + (1 << p) - 1 <= clk; i++) {
            int j = i + (1 << (p - 1));
            if (dis[f[p - 1][i]] < dis[f[p - 1][j]]) 
                f[p][i] = f[p - 1][i];
            else 
                f[p][i] = f[p - 1][j];
    }
}

// 求节点 x 和 y 的 lca
int lca(int x, int y) {
    if (bgn[x] > bgn[y]) 
        swap(x, y);
    int p = lg[bgn[y] - bgn[x] + 1];
    int a = f[p][bgn[x]], b = f[p][bgn[y] - (1 << p) + 1];

    if (dis[a] < dis[b]) 
        return a;
    else 
        return b;
}

void solve() {
    scanf("%d%d%d", &n, &m, &q);

    memset(flag, 0, sizeof(bool) * (n + 3));
    for (int i = 1; i <= m; i++) {
        int x; scanf("%d", &x);
        flag[x] = true;
    }

    for (int i = 1; i <= n; i++) 
        e[i].clear(), v[i].clear();

    for (int i = 1; i < n; i++) {
        int x, y, z; scanf("%d%d%d", &x, &y, &z);
        e[x].push_back(y); v[x].push_back(z);
        e[y].push_back(x); v[y].push_back(z);
    }

    clk = 0; 
    dfs(1, 0);
    preLca();

    while (q--) {
        vector<int> vec;
        int t; scanf("%d", &t);
        while (t--) {
            int x; scanf("%d", &x);
            vec.push_back(x);
        }

        vec.push_back(0);

        sort(vec.begin(), vec.end(), [&](int a, int b) {
            return cost[a] > cost[b];
        });

        int anc = vec[0];
        long long mx = dis[vec[0]], ans = cost[vec[1]];
        // 枚举新的红点要覆盖几个节点
        for (int i = 1; i + 1 < vec.size(); i++) {
            anc = lca(anc, vec[i]);
            mx = max(mx, dis[vec[i]]);
            ans = min(ans, max(mx - dis[anc], cost[vec[i + 1]]));
        }
        printf("%lld\n", ans);
    }
}

int main() {
    lg[1] = 0;
    for (int i = 2; i <= MAXN * 2; i++) lg[i] = lg[i >> 1] + 1;

    int tcase; scanf("%d", &tcase);
    while (tcase--) solve();
    return 0;
}

/*
2
12 2 4
1 9
1 2 1
2 3 4
3 4 3
3 5 2
2 6 2
6 7 1
6 8 2
2 9 5
9 10 2
9 11 3
1 12 10
3 3 7 8
4 4 5 7 8
4 7 8 10 11
3 4 5 12
3 2 3
1 2
1 2 1
1 3 1
1 1
2 1 2
3 1 2 3
*/