// karanaggarwal
#include <bits/stdc++.h>
#include <cstring>
#include <queue>
#include <stack>
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>

using namespace std;

#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
      cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
      const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif

#define si(x) scanf("%d",&x)
#define F first
#define S second
#define PB push_back
#define MP make_pair


typedef long long LL;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<PII> VPII;

const int MN = 100000;

int level[MN], visited[MN];
int ancestor[MN][20];
long long distanc[MN][20]; // Distance[n][i] = distance(n, ancestor[n][i]) ;
set<PII> E[MN];
int C[MN];
int D[MN];
long long DS[MN];
int B[MN*10];

int lvl;
void dfs(int x, int p)
{
   visited[x] = lvl;
   D[x] = 1;
   for(auto c : E[x])
   {
      if(c.F != p)
      {
         dfs(c.F, x);
         D[x] += D[c.F];
      }
   }
}

int find_center(int root)
{
  // trace(root);
   dfs(root,-1);
   int n = D[root];
  // trace(root,n);
   int p = -1;
   while(1)
   {
      int x = -1;
      for(auto c : E[root])
         if(c.F != p and D[c.F] > n/2)
         {
            x = c.F; 
         }
      if(x==-1)return root;
      p = root;
      root = x;
   }
}

void dfs2(int x, int root, long long dist, int p)
{
   ancestor[x][lvl] = root;
   distanc[x][lvl] = dist;
   for(auto c : E[x])
   {
      if(c.F !=p )
         dfs2(c.F,root,dist + c.S, x);
   }
}


int main()
{
   memset(level, -1, sizeof(level));
   memset(visited, -1, sizeof(visited));
   int n; si(n);
   int t; si(t);
   for(int i =0; i<n-1; i++)
   {
      int a,b,c; si(a); si(b); si(c); a--; b--; 
      E[a].insert(MP(b,c));
      swap(a,b);
      E[a].insert(MP(b,c));
   }
//   trace("fdsf");
   int assigned = 0;
   for(int l = 0; assigned < n ; l++)
   {
      lvl = l;
      for(int i = 0; i<n; i++)
      {
         if(visited[i]<lvl and level[i]==-1)
         {
   //         trace(l,i);
            int r = find_center(i);
  //          trace(l,i,r);
            level[r] = lvl;
            assigned++;
            dfs2(r, r, 0, -1);
            for(auto c : E[r])
               E[c.F].erase(MP(r,c.S));
            E[r].clear();
         }
      }
   }
//   for(int i = 0; i<n; i++)trace(i,level[i]);
   for(int i  = 0; i<n; i++)D[i] = 0;
//   for(int l = 0; l<3; l++)
 //     for(int i = 0; i<n; i++)
  //    {
   //      trace(l,i,distanc[i][l], ancestor[i][l]);
    //  }
   while(t--)
   {
      int m; si(m);
      LL ans = 0;
      for(int i = 0; i<m; i++)
      {
         int x; si(x); x--; B[i] = x;
         for(int l = level[x]; l>=0; l--)
         {
            int d = ancestor[x][l];
            D[d]++; DS[d] += distanc[x][l];
         }
      }
      for(int i = 0; i<m; i++)
      {
         int x = B[i];
         for(int l = level[x]; l>=0; l--)
         {
            int d = ancestor[x][l];
            if(l != level[x])
            {
               int d2 = ancestor[x][l+1];
               ans += distanc[x][l] * (D[d]-D[d2]);
            }
         }
      }
      for(int i = 0; i<m; i++)
      {
         int x = B[i];
         int lvl = level[x];
         for(int l = lvl; l>=0; l--)
         {
            int d = ancestor[x][l]; D[d] = 0; DS[d] = 0;
         }
      }
      printf("%lld\n",ans);
   }
	return 0;	
}