#include <bits/stdc++.h>
using namespace std;

const int MAX = 300050;
#define ll long long
 
ll ans = 0;
int N , T , K , cur = 0, timer = 0 , tim = 0;
vector<pair<int, int> >adjList[MAX];
int SUM[MAX] , ST[MAX], S[MAX] , M[MAX] , FLAT[MAX] , P[MAX] , L[MAX], LOG[MAX] , SPARSE_TABLE[20][MAX], FLAT_INV[MAX];
 
inline void buildLogTable( int v ){
    int g = 2;
    while (g <= v) {
        LOG[g] = 1;
        g = (g << 1);
    }
    for (int i = 1; i <= v; i++)
        LOG[i] += LOG[i - 1];
}
 
inline void buildSparseTable( int v ){
 
    for( int i = 0 ; i < v ; i++)
        SPARSE_TABLE[0][i] = FLAT[i];
 
    for (int j = 1; (1 << j) < v; j++) {
        for (int i = 0; i + (1 << j) <= v; i++) {
            int g = L[SPARSE_TABLE[j - 1][i]];
            int p = L[SPARSE_TABLE[j - 1][i + (1 << (j - 1))]];
            SPARSE_TABLE[j][i] = g < p ? SPARSE_TABLE[j - 1][i] : 
                                         SPARSE_TABLE[j - 1][i + (1 << (j - 1))];
        }
    }
 
}
 
inline void dfs( int node , int par , int cost , int depth){
 
    SUM[node] = cost;
    P[node] = par;
    FLAT[timer++] = node;
    L[node] = depth;
 
    for( auto next : adjList[node])
        if( next.first != par )dfs(next.first,node,next.second + cost , depth + 1) , FLAT[timer++] = node;
}
 
 
inline void precompute(){
    dfs( 1 , 1 , 0 , 0);
    buildLogTable( 2 * N - 1 );
    buildSparseTable( 2 * N - 1);
    for( int i = 2 * N - 2 ; i >= 0 ; i-- ) FLAT_INV[FLAT[i]] = i;
}
 
 
inline ll dp(){
    ll res = 0;
    for( int i = N - 1 ; i >= 0 ; i--){
        int node = i;
        for( auto nxt : adjList[node]){
            if( nxt.first == P[node] ) continue;
            res += ST[nxt.first]*1LL*( K - ST[nxt.first])*nxt.second;
            ST[node] += ST[nxt.first];
        }
    }
 
    return res;
}
 
inline int fun(int l, int r) {
    int k = LOG[r - l + 1];
    return L[SPARSE_TABLE[k][l]] <= L[SPARSE_TABLE[k][r - (1 << k) + 1]] ? 
           SPARSE_TABLE[k][l] : SPARSE_TABLE[k][r - (1 << k) + 1];
}
 
inline int lca(int a, int b) {
    return fun(min(FLAT_INV[a], FLAT_INV[b]), max(FLAT_INV[a], FLAT_INV[b]));
}
 
inline int dist( int a , int b){
    return SUM[a] + SUM[b] - ( SUM[lca(a,b)] << 1);
}
 
 
int main(){
 
 
    cin>>N>>T;
 
    for(int i = 1 ; i <= N - 1 ; i++){
        int A , B , C;
        cin>>A>>B>>C;
        adjList[A].emplace_back(make_pair(B,C) );
        adjList[B].emplace_back(make_pair(A,C) );
    }
 
    precompute();
 
 
    while(T--){
 
        cin>>K;
        cur = 0 , ans = 0LL;
 
        for(int i = 1 ; i <= K ; i++){ 
            int x ; 
            cin>>x;
            S[++cur] = x;
            ST[x]++;
        }
 
        if( K >= 400 ){
           ans = dp();
           for( int i = 1 ; i <= N ; i++) ST[i] = 0LL;
       }
        else {
          for( int i = 1 ; i <= cur ; i++ )
            for( int j = i+1 ; j <= cur ; j++)
                ans += dist( S[i] , S[j] );
        }
        cout<<ans<<"\n";
    }
 
    return 0;
}