/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

#include <bits/stdc++.h>

using namespace std;

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         acos(-1.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}


vector < int > adj[100001], vp[100001];
int t = 0, numChild[100001];
LL root_dis[100001], pre[100001];
int lvl[100001], start[100001], endt[100001];
int dfs(int node, int pnt, int dis, LL dd){
    int child = 1;
    lvl[node] = dis;
    start[node] = ++t;
    root_dis[node] = dd;
    REP(i, adj[node].size()){
        if(adj[node][i] == pnt)continue;
        child += dfs(adj[node][i], node, dis + 1, dd + vp[node][i]);
        pre[adj[node][i]] = vp[node][i];
    }
    endt[node] = ++t;
    return numChild[node] = child;
}

vector < int > group[100001];
int cnt = 0, position[100001];
int grp[100001], parent[100001];
void hld(int node, int pnt, int pos){
    position[node] = pos;
    parent[node] = pnt;
    grp[node] = cnt;
    group[cnt].push_back(node);
    int maxVal = 0, child = 0;
    REP(i, adj[node].size()){
        if(adj[node][i] == pnt)continue;
        if(numChild[ adj[node][i] ] > maxVal){
            maxVal = numChild[ adj[node][i] ];
            child = adj[node][i];
        }
    }
    if(child != 0) hld(child, node, pos + 1);
    REP(i, adj[node].size()){
        if(adj[node][i] == pnt || adj[node][i] == child)continue;
        cnt++; hld(adj[node][i], node, 0);
    }
}

int on[100001], tt;
vector< int > vc[100001], use;
vector < LL > sum[100001];
void dfsqu(int node,int pnt){
    if(node == parent[pnt])return;
    int a=grp[node];
    if(grp[pnt] != a) dfsqu(parent[ group[a][0] ], pnt);
    if(on[a] != tt){
        on[a] = tt;
        use.pb(a);
        vc[a].clear();
    }
    vc[a].pb(position[node]);
}


int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int N, T; cin >> N >> T;
    REP(i, N-1){
        int x, y, w; cin >> x >> y >> w;
        adj[x].pb(y); vp[x].pb(w);
        adj[y].pb(x); vp[y].pb(w);
    }
    dfs(1, 0, 1, 0);
    hld(1, 0, 0);
    REP(i, cnt + 1){
        REP(j, group[i].size()){
            sum[i].pb(pre[group[i][j]]);
            if(j > 0) sum[i][j] += sum[i][j-1];
        }
    }
    while(T--){
        tt++;
        int K; cin >> K;
        LL res = 0, tmp = 0;
        use.clear();
        REP(i, K){
            int x; cin >> x;
            tmp += root_dis[x];
            dfsqu(x, 1);
        }

        res = (LL)K * tmp;
        REP(i, use.size()){
            int c = use[i];
            sort(vc[c].begin(), vc[c].end());
            LL cc = 0, ct = 0;
            for(int j = vc[c].size() - 1; j >= 0; j--){
                ct++;
                if(j == 0 || vc[c][j-1] != vc[c][j]){
//                    cout << cc << " " << ct << endl;
                    res -= ct * cc * sum[c][vc[c][j]];
                    cc += ct;
                    res -= ct * cc * sum[c][vc[c][j]];
                    ct = 0;
                }
            }
        }

        cout << res << endl;
    }
}
/*
4 1
1 2 2
2 3 1
3 4 2
4
1 2 3 4

5+3+2 + 3+3+2 + 2+2+2
10
6
6
10
*/