#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

constexpr ll INF = (ll) 1e18;

constexpr int MAXN = (int) 1e5;
constexpr int LOG = 20;

int rmq[LOG + 1][2 * MAXN + 1];
int lg[2 * MAXN + 1];


int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

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

    int t;
    cin >> t;
    while (t--) {
        int n, m, q;
        cin >> n >> m >> q;

        vector<bool> r(n + 1); 
        for (int i = 1; i <= m; i++) {
            int x;
            cin >> x;
            r[x] = 1;
        }

        vector<vector<pair<int, int>>> g(n + 1);
        for (int i = 1; i < n; i++) {
            int x, y, w;
            cin >> x >> y >> w;
            g[x].push_back({y, w});
            g[y].push_back({x, w});
        }

        vector<int> first(n + 1);
        int size = 0;

        vector<ll> sum(n + 1);
        vector<ll> dist(n + 1);

        function<void(int, int, int)> dfs = [&](int node, int par, int anc) {
            if (r[node]) {
                dist[node] = 0;
            } else {
                if (anc == -1) {
                    dist[node] = INF;
                } else {
                    dist[node] = sum[node] - sum[anc];
                }
            }

            rmq[0][++size] = node;
            first[node] = size;

            for (auto itr : g[node]) {
                if (itr.first != par) {
                    sum[itr.first] = sum[node] + itr.second;
                    dfs(itr.first, node, r[node] ? node : anc);
                    rmq[0][++size] = node;
                }
            }
        };

        dfs(1, 0, -1);

        for (int bit = 1; (1 << bit) <= size; bit++) {
            for(int i = 1; i + (1 << bit) <= size + 1; i++) {
                int a = rmq[bit - 1][i], b = rmq[bit - 1][i + (1 << (bit - 1))];
                rmq[bit][i] = (sum[a] < sum[b] ? a : b);
            }
        }

        auto GetLCA = [&](int x, int y) {
            x = first[x], y = first[y];

            if(x > y) swap(x, y);

            int bit = lg[y - x + 1];
            int a = rmq[bit][x], b = rmq[bit][y - (1 << bit) + 1];
            return (sum[a] < sum[b] ? a : b);
        };

        while (q--) {
            int k;
            cin >> k;

            vector<int> nodes(k);
            for (auto& node : nodes) {
                cin >> node;
            }

            auto Check = [&](ll D) {
                int lca = -1;
                for (auto node : nodes) {
                    if (dist[node] <= D) continue;
                    
                    lca = (lca == -1 ? node : GetLCA(lca, node));
                }


                for (auto node : nodes) {
                    if (dist[node] > D && sum[node] - sum[lca] > D) {
                        return false;
                    }
                }
                return true;
            };

            ll result = -1;
            for (ll step = 1LL << 50; step; step >>= 1) {
                if (Check(result + step) == false) {
                    result += step;
                }
            }
            cout << result + 1 << "\n";
        }
    }
    

    return 0;
}