#include <bits/stdc++.h>

using i64 = long long;

void solve() {
    int n, m, q;
    std::cin >> n >> m >> q;

    std::vector<bool> red(n);
    for (int i = 0; i < m; ++i) {
        int x;
        std::cin >> x;
        --x;
        red[x] = true;
    }

    std::vector<std::vector<std::pair<int, int>>> adj(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v, w;
        std::cin >> u >> v >> w;
        --u, --v;
        adj[u].emplace_back(v, w), adj[v].emplace_back(u, w);
    }

    std::vector<int> fa(n, -1);
    std::vector<i64> dep(n), top(n);
    std::vector<int> dfn(n, -1);
    int cur = 0;
    auto dfs1 = [&](auto self, int u) -> void {
        dfn[u] = cur++;
        for (auto [v, w] : adj[u]) {
            if (v == fa[u]) {
                continue;
            }
            fa[v] = u, dep[v] = dep[u] + w;
            if (!red[v]) {
                top[v] = top[u] + w;
            }
            self(self, v);
        }
    };
    fa[0] = 0;
    dfs1(dfs1, 0);
    
    const int lg = std::__lg(n) + 1;
    std::vector st(lg + 1, std::vector<int>(n));
    for (int i = 0; i < n; ++i) {
        st[0][dfn[i]] = fa[i];
    }
    auto cmp = [&](int x, int y) {
        return dfn[x] < dfn[y];
    };
    for (int i = 0; i < lg; ++i) {
        for (int j = 0; j <= n - (2 << i); ++j) {
            st[i + 1][j] = std::min(st[i][j], st[i][j + (1 << i)], cmp);
        }
    }
    auto lca = [&](int u, int v) {
        if (u == v) {
            return u;
        }
        u = dfn[u], v = dfn[v];
        if (u > v) {
            std::swap(u, v);
        }
        int k = std::__lg(v - u++);
        return std::min(st[k][u], st[k][v - (1 << k) + 1], cmp);
    };

    std::vector<int> s;
    std::vector<int> idx(n);
    std::vector<std::vector<int>> t(n);

    std::vector<bool> vis(n);
    while (q--) {
        int k;
        std::cin >> k;
        s.resize(k);
        for (int i = 0; i < k; ++i) {
            std::cin >> s[i];
            --s[i];
            vis[s[i]] = true;
        }
        
        std::sort(s.begin(), s.end(), [&](int x, int y) {
            return dfn[x] < dfn[y];
        });
        for (int i = k - 1; i > 0; --i) {
            s.push_back(lca(s[i], s[i - 1]));
        }
        std::sort(s.begin(), s.end(), [&](int x, int y) {
            return dfn[x] < dfn[y];
        });
        s.erase(std::unique(s.begin(), s.end()), s.end());

        for (int i = 0; i < int(s.size()); ++i) {
            idx[s[i]] = i;
            t[i].clear();
        }
        for (int i = 1; i < int(s.size()); ++i) {
            int f = lca(s[i], s[i - 1]);
            t[idx[f]].push_back(i);
        }

        i64 lo = 0, hi = 1e18;
        while (lo < hi) {
            i64 m = (lo + hi) / 2;
            int cnt = 0;
            auto dfs = [&](auto self, int u) -> i64 {
                i64 f = -1;
                if (vis[s[u]] && !red[s[u]]) {
                    f = 0;
                }
                for (auto v : t[u]) {
                    i64 x = self(self, v);
                    if (x == -1) {
                        continue;
                    }
                    x += std::min(top[s[v]], dep[s[v]] - dep[s[u]]);
                    if (x > m) {
                        cnt += 1;
                    } else if (dep[s[v]] - dep[s[u]] <= top[s[v]]) {
                        f = std::max(f, x);
                    }
                }
                return f;
            };
            i64 d = dfs(dfs, 0);
            if (d != -1 && d + top[s[0]] > m) {
                cnt += 1;
            }
            if (cnt > 1) {
                lo = m + 1;
            } else {
                hi = m;
            }
        }
        std::cout << lo << '\n';

        for (auto x : s) {
            vis[x] = false;
        }
    }
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}