#include <algorithm>
#include <array>
#include <cstdint>
#include <ios>
#include <iostream>
#include <utility>
#include <vector>

template <typename F>
class y_combinator {

private:

    F f;

public:

    explicit y_combinator(F&& f) : f(f) {}

    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const {

        return f(*this, std::forward<Args>(args)...);

    }

};

template <typename F>
y_combinator(F) -> y_combinator<F>;

void solve() {

    using edge_t = std::array<std::int32_t, 2>;

    std::int32_t n;

    std::cin >> n;

    std::vector<std::vector<edge_t>> adj(n);
    std::int64_t mx = 0;

    for (std::int32_t i = 0; i < n - 1; ++i) {
        std::int32_t u;
        std::int32_t v;
        std::int32_t w;
        std::cin >> u >> v >> w;
        --u;
        --v;
        adj[u].push_back(edge_t({v, w}));
        adj[v].push_back(edge_t({u, w}));
        mx += w;
    }

    std::int32_t m;

    std::cin >> m;

    std::vector<std::int32_t> deps(n);
    std::vector<std::int32_t> dfn(n);
    std::vector<std::int64_t> dp(n);
    std::vector<bool> in(n);
    const std::int32_t lvls = 32 - __builtin_clz(n - 1);
    std::vector<std::int64_t> mns(n, mx + 1);
    std::int32_t tm = 0;
    std::vector<std::vector<std::int32_t>> v_adj(n);

    std::vector ancs(lvls, std::vector(n, std::int32_t(-1)));

    y_combinator(
        [&](auto self, std::int32_t node, std::int32_t par) -> void {
            ancs[0][node] = par;
            deps[node] = par != -1 ? deps[par] + 1 : 0;
            dfn[node] = tm;
            ++tm;
            for (const auto& [nbr, w] : adj[node]) {
                if (nbr != par) {
                    mns[nbr] = std::min<std::int64_t>(mns[node], w);
                    self(nbr, node);
                }
            }
        }
    )(0, -1);

    for (std::int32_t i = 1; i < lvls; ++i) {
        for (std::int32_t j = 0; j < n; ++j) {
            const std::int32_t anc = ancs[i - 1][j];
            ancs[i][j] = anc != -1 ? ancs[i - 1][anc] : -1;
        }
    }

    for (std::int32_t i = 0; i < m; ++i) {
        std::int32_t k;
        std::cin >> k;
        std::vector<std::int32_t> h(k + 1);
        for (std::int32_t j = 0; j < k; ++j) {
            std::cin >> h[j];
            --h[j];
        }
        for (std::int32_t j = 0; j < k; ++j) {
            in[h[j]] = true;
        }
        h.reserve((k + 1) * 2 - 1);
        const auto cmp = [&](std::int32_t node_1, std::int32_t node_2) -> bool {
            return dfn[node_1] < dfn[node_2];
        };
        const auto lca = [&](std::int32_t node_1, std::int32_t node_2) -> std::int32_t {
            for (std::int32_t i = lvls - 1; i >= 0; --i) {
                if (deps[node_1] - deps[node_2] >= 1 << i) {
                    node_1 = ancs[i][node_1];
                }
                if (deps[node_2] - deps[node_1] >= 1 << i) {
                    node_2 = ancs[i][node_2];
                }
            }
            if (node_1 == node_2) {
                return node_1;
            }
            for (std::int32_t i = lvls - 1; i >= 0; --i) {
                if (ancs[i][node_1] != ancs[i][node_2]) {
                    node_1 = ancs[i][node_1];
                    node_2 = ancs[i][node_2];
                }
            }
            return ancs[0][node_1];
        };
        std::sort(std::begin(h), std::end(h), cmp);
        for (std::int32_t j = 0; j < k; ++j) {
            h.push_back(lca(h[j], h[j + 1]));
        }
        std::sort(std::begin(h), std::end(h), cmp);
        h.erase(std::unique(std::begin(h), std::end(h)), std::end(h));
        const std::int32_t sz = std::size(h);
        for (std::int32_t j = 1; j < sz; ++j) {
            v_adj[lca(h[j - 1], h[j])].push_back(h[j]);
        }
        for (std::int32_t j = sz - 1; j >= 0; --j) {
            dp[h[j]] = mns[h[j]];
            if (!in[h[j]]) {
                std::int64_t c_cst = 0;
                for (auto x : v_adj[h[j]]) {
                    c_cst += dp[x];
                }
                dp[h[j]] = std::min(dp[h[j]], c_cst);
            }
        }
        std::cout << dp[0] << '\n';
        for (auto x : h) {
            in[x] = false;
            v_adj[x].clear();
        }
    }

}

int main() {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    solve();

    return 0;

}