#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

struct heavy_light_decomposition {
    int n;
    vector<vector<int>> G;
    vector<int> par, sz, in, nxt;

    heavy_light_decomposition(int n) : n(n), G(n), par(n), sz(n, 1), in(n), nxt(n) {}
    void add_edge(int x, int y) {
        G[x].push_back(y);
        G[y].push_back(x);
    }
    void build() {
        auto dfs1 = [&](auto self, int s, int p) -> void {
            for (int i = 0; i < (int)G[s].size(); ++i) {
                int t = G[s][i];
                if (t == p) {
                    swap(G[s][i--], G[s].back());
                    G[s].pop_back();
                } else {
                    par[t] = s;
                    self(self, t, s);
                    sz[s] += sz[t];
                    if (sz[t] > sz[G[s][0]]) {
                        swap(G[s][0], G[s][i]);
                    }
                }
            }
        };
        dfs1(dfs1, 0, -1);
        int id = 0;
        auto dfs2 = [&](auto self, int s) -> void {
            in[s] = id++;
            for (int t : G[s]) {
                if (t == G[s][0]) {
                    nxt[t] = nxt[s];
                } else {
                    nxt[t] = t;
                }
                self(self, t);
            }
        };
        dfs2(dfs2, 0);
    }
    int lca(int s, int t) {
        while (1) {
            if (in[s] > in[t]) swap(s, t);
            if (nxt[s] == nxt[t]) return s;
            t = par[nxt[t]];
        }
    }
};

void slv() {
    int n, m, q;
    cin >> n >> m >> q;
    vector<bool> red(n);
    for (int i = 0; i < m; i++) {
        int x;
        cin >> x;
        red[x - 1] = true;
    }
    map<pair<int, int>, int> edge;
    heavy_light_decomposition hld(n);
    for (int i = 0; i < n - 1; i++) {
        int x, y, z;
        cin >> x >> y >> z;
        x -= 1, y -= 1;
        edge[{x, y}] = edge[{y, x}] = z;
        hld.add_edge(x, y);
    }
    hld.build();
    vector<ll> cost(n), dist(n);
    auto dfs = [&](auto dfs, int s, ll sum, ll c) -> void {
        if (red[s]) c = 0;
        dist[s] = sum;
        cost[s] = c;
        for (int t : hld.G[s]) {
            dfs(dfs, t, sum + edge[{s, t}], c + edge[{s, t}]);
        }
    };
    dfs(dfs, 0, 0, 0);
    while (q--) {
        int k;
        cin >> k;
        vector<int> v(k);
        ll L = -1, R = 0;
        for (int i = 0; i < k; i++) {
            cin >> v[i];
            v[i] -= 1;
            R = max(R, cost[v[i]]);
        }
        sort(v.begin(), v.end(), [&](auto i, auto j) { return cost[i] > cost[j]; });
        vector<int> lca(v.size());
        lca[0] = v[0];
        for (int i = 1; i < v.size(); i++) {
            lca[i] = hld.lca(lca[i - 1], v[i]);
        }

        while (R - L > 1) {
            ll mid = (L + R) / 2;
            int id = -1;
            int j = 0;
            for (int i : v) {
                if (cost[i] <= mid) break;
                id = lca[j++];
            }
            bool ok = true;
            if (id != -1) {
                for (int i : v) {
                    if (cost[i] <= mid) continue;
                    if (dist[i] - dist[id] > mid) {
                        ok = false;
                        break;
                    }
                }
            }
            if (ok) R = mid;
            else L = mid;
        }
        cout << R << "\n";
    }
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q;
    cin >> q;
    while (q--) {
        slv();
    }
}