#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

#define N 210000

int len, Time, n, t, a, b, c, k, now;
int Next[N], till[N], go[N], f[N], L[N], R[N], dep[N], l[N], fa[110000][21];
int zhan[N], x[N];
bool used[N];
int numd[N], numu[N];
long long dpd[N], dpu[N];
vector <int> ve[N];

bool cmp(int x, int y) {
	return L[x] < L[y];
}

void add(int x, int y, int z) {
	Next[++len] = till[x];
	till[x] = len;
	go[len] = y;
	f[len] = z;
}

void dfs(int k, int ff) {
	L[k] = ++Time;
	l[k] = l[ff] + 1;
	fa[k][0] = ff;
	for (int i = 1; i <= 20; i++)
		fa[k][i] = fa[fa[k][i - 1]][i - 1];
	for (int i = till[k]; i; i = Next[i])
		if (go[i] != ff) {
			dep[go[i]] = dep[k] + f[i];
			dfs(go[i], k);
		}
	
	R[k] = Time;
}

int lca(int x, int y) {
	if (l[x] < l[y])
		swap(x, y);
	for (int i = 20; i >= 0; i--)
		if (l[fa[x][i]] >= l[y]) x = fa[x][i];
	if (x == y)
		return x;
	for (int i = 20; i >= 0; i--)
		if (fa[x][i] != fa[y][i])
			x = fa[x][i], y = fa[y][i];
	return fa[x][0];
}

void dfs1(int x) {
	while (true) {
		if (now > zhan[0] || L[zhan[now]] > R[x])
			return ;
		ve[x].push_back(zhan[now]);
		dfs1(zhan[now++]);
	}
}

void dfs2(int k) {
	dpd[k] = 0;
	numd[k] = x[k];
	for (int i = 0; i < (int) ve[k].size(); i++) {
		dfs2(ve[k][i]);
		numd[k] += numd[ve[k][i]];
		dpd[k] += dpd[ve[k][i]] + 1LL * (dep[ve[k][i]] - dep[k]) * numd[ve[k][i]];
	}
}

void dfs3(int k, long long sum, int num) {
	dpu[k] = sum;
	for (int i = 0; i < (int) ve[k].size(); i++) {
		int nn = num + numd[k] - numd[ve[k][i]];
 		dfs3(ve[k][i], sum + 1LL * nn * (dep[ve[k][i]] - dep[k]) + dpd[k] - dpd[ve[k][i]] - 1LL * numd[ve[k][i]] * (dep[ve[k][i]] - dep[k]), nn);
	}
}

int main() {
	scanf("%d%d", &n, &t);
	len = 1;
	for (int i = 1; i < n; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
		add(b, a, c);
	}
	dfs(1, 0);


	while (t--) {
		scanf("%d", &k);
		for (int i = 1; i <= k; i++) {
			scanf("%d", &a);
			if (used[a]) x[a]++;
			else used[a] = true, x[a] = 1, zhan[++zhan[0]] = a;
		}
		sort(zhan + 1, zhan + zhan[0] + 1, cmp);
		for (int i = zhan[0]; i > 1; i--)
			if (!used[lca(zhan[i], zhan[i - 1])])
				zhan[++zhan[0]] = lca(zhan[i], zhan[i - 1]), used[zhan[zhan[0]]] = true;
		sort(zhan + 1, zhan + zhan[0] + 1, cmp);
		
		now = 2;

		dfs1(zhan[1]);

		
		dfs2(zhan[1]);

		dfs3(zhan[1], 0, 0);
		
		long long ans = 0;
		for (int i = 1; i <= zhan[0]; i++)
			ans += x[zhan[i]] * (dpd[zhan[i]] + dpu[zhan[i]]);
		


		printf("%lld\n", ans / 2);
		for (int i = 1; i <= zhan[0]; i++) {
			int t = zhan[i];
			ve[t].clear();
			used[t] = false;
			x[t] = 0;
		}
		zhan[0] = 0;
	}
}