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

const int MAXn = 1e5+10;
const int LG = 18;
typedef long long ll;

int T, n;

vector<int> nb[MAXn], nbw[MAXn];

int h[MAXn];
vector<int> child[MAXn], childw[MAXn];
int par[MAXn], parw[MAXn];

int post[MAXn];
int posti = 0;
bool mark[MAXn];
void dfs(int v) {
	mark[v] = true;
	post[v] = posti++;
	for(int i = 0; i < (int)nb[v].size(); i++) {
		if (!mark[nb[v][i]]) {
			par[nb[v][i]] = v;
			parw[nb[v][i]] = nbw[v][i];
			child[v].push_back(nb[v][i]);
			childw[v].push_back(nbw[v][i]);
			h[nb[v][i]] = h[v] + 1;
			dfs(nb[v][i]);
		}
	}
}

int exppar[MAXn][LG];
ll expparw[MAXn][LG];
void initlcm(int v = 0) {
	exppar[v][0] = par[v];
	expparw[v][0] = parw[v];
	for(int i = 1; i < LG; i++) {
		if (exppar[v][i-1] == -1) {
			exppar[v][i] = -1;
		} else {
			exppar[v][i] = exppar[exppar[v][i-1]][i-1];
			if (exppar[v][i] != -1) {
				expparw[v][i] = expparw[v][i-1] + expparw[exppar[v][i-1]][i-1];
			}
		}
	}
	for(int i = 0; i < (int)child[v].size(); i++) {
		initlcm(child[v][i]);
	}
}

pair<int, ll> lcm(int v, int u) {
	if (h[v] > h[u])
		swap(v, u);
	ll cost = 0;
	for(int i = LG-1; i >= 0; i--) {
		if ((1<<i) <= h[u]-h[v]) {
			cost += expparw[u][i];
			u = exppar[u][i];	
		}
	}
	if (u == v) 
		return make_pair(u, cost);
	for(int i = LG-1; i >= 0; i--) {
		if (exppar[v][i] != exppar[u][i]) {
			cost += expparw[v][i] + expparw[u][i];
			v = exppar[v][i];
			u = exppar[u][i];
		}
	}
	cost += expparw[v][0] + expparw[u][0];
	v = exppar[v][0];
	u = exppar[u][0];
	return make_pair(v, cost);
}

ll solve(vector<int> v) {
	int m = v.size();
	vector<int> q, c;
	q.push_back(v[0]);
	c.push_back(1);
	ll res = 0;
	for(int i = 1; i < (int)v.size(); i++) {
		int u = lcm(v[i-1], v[i]).first;
		int tc = 0;
		int lu = -1;
		while(q.size() && h[u] < h[q.back()]) {
			if (lu != -1) {
				res += lcm(lu, q.back()).second * tc * (m-tc);
			}
			lu = q.back();
			tc += c.back();
			q.pop_back();
			c.pop_back();
		}
		if(q.empty() || q[0] != u) {
			q.push_back(u);
			c.push_back(tc);
		} else {
			c.back() += tc;
		}
		if (lu != -1) 
			res += lcm(u, lu).second * tc * (m-tc);
		if (q.back() == v[i])
			c.back()++;
		else {
			q.push_back(v[i]);
			c.push_back(1);
		}
	}
	while((int)q.size() > 1) {
		res += lcm(q.back(), q[q.size()-2]).second * c.back() * (m - c.back());
		c[c.size()-2] += c.back();
		c.pop_back();
		q.pop_back();
	}
	return res;
}

int main() {
	ios::sync_with_stdio(false);
	cin >> n >> T;
	for(int i = 0; i < n-1; i++) {
		int v, u, c;
		cin >> v >> u >> c;
		v--; u--;
		nb[v].push_back(u);
		nb[u].push_back(v);
		nbw[v].push_back(c);
		nbw[u].push_back(c);
	}
	par[0] = -1;
	dfs(0);
	initlcm();
	for(; T > 0; T--) {
		int m;
		cin >> m;
		vector<pair<int, int> > sorted;
		for(int i = 0; i < m; i++) {
			int v;
			cin >> v; v--;
			sorted.push_back(make_pair(post[v], v));
		}
		sort(sorted.begin(), sorted.end());
		vector<int> v;
		for(int i = 0; i < m; i++)
			v.push_back(sorted[i].second);
		cout << solve(v) << endl;
	}
	return 0;
}