#include <vector> 
#include <list> 
#include <map> 
#include <set> 
#include <queue>
#include <stack> 
#include <bitset> 
#include <algorithm> 
#include <numeric> 
#include <utility> 
#include <sstream> 
#include <iostream> 
#include <iomanip> 
#include <cstdio> 
#include <cmath> 
#include <cstdlib> 
#include <ctime> 
#include <cstring> 


using namespace std;


#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)

int N, T;
int cur_set[110000];
vector<pair<int, int>> adj[110000];
long long torot[110000];
map<int, pair<long long, int>> tree_nodes[110000];
long long ans[110000];

void merge(int a, int b) {
	if (tree_nodes[cur_set[a]].size() < tree_nodes[cur_set[b]].size()) {
		swap(cur_set[a], cur_set[b]);
	}

	for (auto it = tree_nodes[cur_set[b]].begin(); it != tree_nodes[cur_set[b]].end(); it++) {
		if (tree_nodes[cur_set[a]].count(it->first)) {
			ans[it->first] += (it->second.first) * tree_nodes[cur_set[a]][it->first].second;
			ans[it->first] += (it->second.second) * tree_nodes[cur_set[a]][it->first].first;
			ans[it->first] -= (it->second.second) * 2 * torot[a] * tree_nodes[cur_set[a]][it->first].second;
			
			//printf("ans[%d] = %lld\n", it->first, ans[it->first]);
			tree_nodes[cur_set[a]][it->first].first += it->second.first;
			tree_nodes[cur_set[a]][it->first].second += it->second.second;
		}
		else {
			tree_nodes[cur_set[a]][it->first] = it->second;
		}
	}
}

void dfsT(int v, int p, long long tr) {
	torot[v] = tr;
	for (pair<int, int> c : adj[v]) if (c.first != p) {
		dfsT(c.first, v, tr+c.second);
	}
}

void dfs_final(int v, int p) {
	for (pair<int, int> c : adj[v]) if (c.first != p) {
		dfs_final(c.first, v);
		merge(v, c.first);
	}
}

void solve()
{
	scanf("%d %d", &N, &T);
	REP(i, N) {
		cur_set[i] = i;
		adj[i].clear();
		tree_nodes[i].clear();
	}

	REP(i, N - 1) {
		int a, b, c;
		scanf("%d %d %d", &a, &b, &c); a--; b--;
		adj[a].push_back({ b, c });
		adj[b].push_back({ a, c });
	}

	dfsT(0, -1, 0);

	REP(i, T) {
		ans[i] = 0;

		int k;
		for (scanf("%d", &k); k; k--) {
			int a;
			scanf("%d", &a); a--;
			if (tree_nodes[a].count(i)) {
				tree_nodes[a][i].second++;
				tree_nodes[a][i].first += torot[a];
			}
			else {
				tree_nodes[a][i] = { torot[a], 1 };
			}
		}
	}

	dfs_final(0, -1);
	
	REP(i, T) {
		printf("%lld\n", ans[i]);
	}
}
int main() {
    solve();
}