#include<bits/stdc++.h>

using namespace std;

#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()

using ll = long long;

const int LOG = 20;

template<typename T>
struct sparse_table {
    vector<array<T, LOG>> spt;

    sparse_table() = default;
    sparse_table(vector<T> a) {
        int n = a.size();
        spt.resize(n);
        for (int i = 0; i < n; ++i) {
            spt[i][0] = a[i];
        }
        for (int h = 0; 1 << h < n; ++h) {
            for (int i = 0; i + (1 << h) < n; ++i) {
                spt[i][h + 1] = min(spt[i][h], spt[i + (1 << h)][h]);
            }
        }
    }

    T get(int l, int r) {
        int k = 31 - __builtin_clz(r - l + 1);
        return min(spt[l][k], spt[r - (1 << k) + 1][k]);
    }
};

struct LCA {
    int n;
    vector<vector<pair<int, int>>> g;
    sparse_table<pair<int, int>> spt;
    vector<int> tin;

    LCA() = default;
    LCA(int n) : n(n) {
        g.resize(n);
        tin.assign(n, 0);
    }

    void dfs(int u, int p, int d, vector<pair<int, int>>& vv) {
        tin[u] = vv.size();
        vv.emplace_back(d, u);
        for (auto [to, w] : g[u]) {
            if (to != p) {
                dfs(to, u, d + 1, vv);
                vv.emplace_back(d, u);
            }
        }
    }

    void build() {
        vector<pair<int, int>> vv;
        dfs(0, -1, 0, vv);
        spt = sparse_table<pair<int, int>>(vv);
    }

    int lca(int u, int v) {
        int l = tin[u], r = tin[v];
        if (l > r) swap(l, r);
        return spt.get(l, r).second;
    }

    vector<pair<int, int>>& operator[](int i) {
        return g[i];
    }
};

template<typename T>
struct segtree {
    int R;
    vector<T> tr;

    segtree() = default;
    segtree(int n) {
        R = 1;
        while (R < n) R <<= 1;
        tr.assign(2 * R, 0);
    }

    void update(int k, int x) {
        k += R;
        tr[k] = x;
        while (k > 1) {
            k >>= 1;
            tr[k] = tr[k << 1] + tr[k << 1 | 1];
        }
    }

    T get(int l, int r) {
        T res = 0;
        for (l += R, r += R; l <= r; l >>= 1, r >>= 1) {
            if (l & 1) res += tr[l++];
            if (~r & 1) res += tr[r--];
        }
        return res;
    }
};

void solve() {
    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] = 1;
    }
    LCA tr(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        tr[u].emplace_back(v, w);
        tr[v].emplace_back(u, w);
    }
    tr.build();
    vector<ll> d(n);
    vector<int> vert(n, -1);
    vector<int> tin(n), tout(n);
    int tim = 0;
    auto dfs = [&](auto dfs, int u, int p) -> void {
        tin[u] = tim++;
        if (red[u]) vert[u] = u;
        for (auto [to, w] : tr[u]) {
            if (to != p) {
                d[to] = d[u] + w;
                vert[to] = vert[u];
                dfs(dfs, to, u);
            }
        }
        tout[u] = tim - 1;
    };
    dfs(dfs, 0, -1);
    while (q--) {
        int k;
        cin >> k;
        vector<int> a(k);
        for (auto& i : a) cin >> i, --i;
        auto check = [&](ll x) -> bool {
            vector<int> b;
            for (auto i : a) {
                if (d[i] - d[vert[i]] > x) b.push_back(i);
            }
            if (b.empty()) return 1;
            int lc = b[0];
            for (auto i : b) lc = tr.lca(lc, i);
            bool ok = 1;
            for (auto i : b) ok &= d[i] - d[lc] <= x;
            return ok;
        };
        ll L = -1, R = 1e18;
        while (R - L > 1) {
            ll M = (L + R) / 2;
            if (check(M)) R = M;
            else L = M;
        }
        cout << R << '\n';
    }
}

int main() {
#ifndef LOCAL
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#else
    freopen("input.txt", "r", stdin);
#endif
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}