#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int MAXN = 100'100;
const int K = 17;

vector<pair<int, int>> G[MAXN];
bool is_red[MAXN];
long long pref_sum[MAXN];
long long weight[MAXN];
int up[MAXN][K];
int depth[MAXN];

void dfs(int v, int p, int w, long long sum) {
    up[v][0] = p;
    depth[v] = w;
    pref_sum[v] = sum;
    for (auto [u, c] : G[v]) {
        if (u == p)
            continue;
        if (is_red[u])
            weight[u] = 0;
        else
            weight[u] = weight[v] + c;
        dfs(u, v, w + 1, sum + c);
    }
}

int la(int v, int d) {
    for (int k = K - 1; k >= 0; --k) {
        if (d >= (1 << k)) {
            d -= 1 << k;
            v = up[v][k];
        }
    }
    return v;
}

int lca(int u, int v) {
    if (depth[u] > depth[v])
        u = la(u, depth[u] - depth[v]);
    else
        v = la(v, depth[v] - depth[u]);
    if (u == v)
        return u;
    for (int k = K - 1; k >= 0; --k) {
        if (up[v][k] != up[u][k]) {
            v = up[v][k];
            u = up[u][k];
        }
    }
    return up[v][0];
}

void solve() {
    int n, m, q;
    cin >> n >> m >> q;
    fill(is_red, is_red + n, false);
    for (int i = 0; i < m; ++i) {
        int v;
        cin >> v;
        is_red[v - 1] = true;
    }
    for (int i = 1; i < n; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        G[a - 1].emplace_back(b - 1, c);
        G[b - 1].emplace_back(a - 1, c);
    }
    dfs(0, 0, 0, 0);
    for (int j = 1; j < K; ++j) {
        for (int v = 0; v < n; ++v)
            up[v][j] = up[up[v][j - 1]][j - 1];
    }
    vector<int> cur;
    while (q--) {
        int cnt;
        cin >> cnt;
        cur.resize(cnt);
        for (int i = 0; i < cnt; ++i) {
            cin >> cur[i];
            --cur[i];
        }
        stable_sort(cur.begin(), cur.end(), [](int a, int b) {
            return weight[a] > weight[b];
        });
        long long ans = weight[cur[0]];
        int ancestor = cur[0];
        long long mx_pref_sum = pref_sum[cur[0]];
        for (int i = 0; i < cur.size(); ++i) {
            ancestor = lca(ancestor, cur[i]);
            mx_pref_sum = max(mx_pref_sum, pref_sum[cur[i]]);
            long long cur_val = mx_pref_sum - pref_sum[ancestor];
            if (i + 1 < cur.size())
                cur_val = max(cur_val, weight[cur[i + 1]]);
            ans = min(ans, cur_val);
        }
        cout << ans << '\n';
    }
    for (int i = 0; i < n; ++i)
        G[i].clear();
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}