#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=25e4+10;
const int maxm=2e6+10;
inline int read(){
    int x=0,w=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c<='9'&&c>='0'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*w;
}
int n,m;
struct Tree{
    struct edge{
        int v,w;
        edge()=default;
        edge(int v_,int w_):v(v_),w(w_){}
    };
    vector<edge> E[maxn];
    inline void add_edge(int u,int v,int w){
        E[u].push_back(edge(v,w));
    }
    int fa[maxn],dep[maxn],siz[maxn],son[maxn];
    int dfn[maxn],dfncnt,top[maxn];
    int mn[maxn][18];
    void dfs1(int u,int f,int d){
        fa[u]=f,dep[u]=d,siz[u]=1;
        int maxson=-1;
        for(edge e:E[u]){
            int v=e.v,w=e.w;
            if(v==f) continue;
            dfs1(v,u,d+1);
            siz[u]+=siz[v];
            if(siz[v]>maxson) son[u]=v,maxson=siz[v];
        }
    }
    void dfs2(int u,int t){
        dfn[u]=++dfncnt,top[u]=t;
        if(!son[u]) return;
        dfs2(son[u],t);
        for(edge e:E[u]){
            int v=e.v;
            if(v==fa[u]||v==son[u]) continue;
            dfs2(v,v);
        }
    }
    void dfs3(int u){
        for(edge e:E[u]){
            int v=e.v,w=e.w;
            if(v==fa[u]) continue;
            mn[dfn[v]][0]=w;
            dfs3(v);
        }
    }
    inline void build_mn(){
        mn[1][0]=0x3f3f3f3f;
        dfs3(1);
        for(int k=1;k<=17;++k){
            for(int i=1;i+(1<<k)-1<=n;++i){
                mn[i][k]=min(mn[i][k-1],mn[i+(1<<k-1)][k-1]);
            }
        }
    }
    inline int query_mn(int l,int r){
        int k=log2(r-l+1);
        return min(mn[l][k],mn[r-(1<<k)+1][k]);
    }
    inline int get_LCA(int u,int v){
        while(top[u]!=top[v]){
            if(dep[top[u]]>dep[top[v]]) swap(u,v);
            v=fa[top[v]];
        }
        if(dep[u]>dep[v]) swap(u,v);
        return u;
    }
    inline int get_mn(int u,int v){
        int res=0x3f3f3f3f;
        while(top[u]!=top[v]){
            if(dep[top[u]]>dep[top[v]]) swap(u,v);
            res=min(res,query_mn(dfn[top[v]],dfn[v]));
            v=fa[top[v]];
            //printf("uv:%d %d %d\n",u,v,res);
        }
        if(dep[u]>dep[v]) swap(u,v);
        if(u!=v) res=min(res,query_mn(dfn[u]+1,dfn[v]));
        return res;
    }
    int id[maxn];
    bool mark[maxn];
    int st[maxn],tp;
    struct EDGE{
        int to,w,nxt;
    }e[maxm];
    int head[maxn],cnt;
    inline void add_EDGE(int u,int v,int w){
        e[++cnt].to=v,e[cnt].w=w,e[cnt].nxt=head[u],head[u]=cnt;
    }
    inline void build(){
        tp=0,st[++tp]=1,st[++tp]=id[1];
        head[1]=head[id[1]]=0;
        for(int i=2;i<=id[0];++i){
            int u=id[i];
            //找到第一个次栈顶深度小于等于LCA的
            //printf("%d %d %d %d\n",u,st[tp],get_LCA(u,st[tp]),st[tp-1]);
            if(get_LCA(u,st[tp])==st[tp]){
                st[++tp]=u;
                head[u]=0;
                continue;
            }
            while(tp>1&&dep[get_LCA(u,st[tp])]<dep[st[tp-1]]){
                add_EDGE(st[tp-1],st[tp],get_mn(st[tp-1],st[tp]));
                //printf("%d %d %d\n",st[tp-1],st[tp],get_mn(st[tp-1],st[tp]));
                --tp;
            }
            //LCA已然入栈
            if(get_LCA(u,st[tp])==st[tp-1]){
                head[u]=0;
                add_EDGE(st[tp-1],st[tp],get_mn(st[tp-1],st[tp]));
                //printf("%d %d %d\n",st[tp-1],st[tp],get_mn(st[tp-1],st[tp]));
                st[tp]=u;
            }
            else{
                int lca=get_LCA(u,st[tp]);
                head[lca]=0,head[u]=0;
                add_EDGE(lca,st[tp],get_mn(lca,st[tp]));
                //printf("%d %d %d\n",lca,st[tp],get_mn(lca,st[tp]));
                st[tp]=lca,st[++tp]=u;
            }
            /*for(int i=head[1];i;i=e[i].nxt) printf("%d ",e[i].to);
            printf("\n");*/
        }
        while(tp>1){
            add_EDGE(st[tp-1],st[tp],get_mn(st[tp-1],st[tp]));
            //printf("%d %d %d\n",st[tp-1],st[tp],get_mn(st[tp-1],st[tp]));
            --tp;
        }
    }
    ll dp[maxn];
    void dfs(int u){
        dp[u]=0;
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to,w=e[i].w;
            //printf("%d->%d %d\n",u,v,w);
            dfs(v);
            if(mark[v]) dp[u]+=w;
            else dp[u]+=min(dp[v],(ll)w);
        }
    }
    inline void solve(){
        id[0]=read();
        for(int i=1;i<=id[0];++i) mark[id[i]=read()]=1;
        sort(id+1,id+id[0]+1,[&](int x,int y){
            return dfn[x]<dfn[y];
        });
        build();
        dfs(1);
        printf("%lld\n",dp[1]);
        for(int i=1;i<=id[0];++i) mark[id[i]]=0;
    }
}T;
int main(){
    n=read();
    for(int i=1;i<n;++i){
        int u=read(),v=read(),w=read();
        T.add_edge(u,v,w);
        T.add_edge(v,u,w);
    }
    T.dfs1(1,0,0);
    T.dfs2(1,1);
    T.build_mn();
    /*for(int i=1;i<=n;++i){
        printf("u:%d dfn:%d top:%d\n",i,T.dfn[i],T.top[i]);
    }*/
    m=read();
    while(m--){
        T.solve();
    }
    return 0;
}