import java.io.*;
import java.util.*;

public class WorldCupCity {

	static final int magic = 405;
	static int n, t, k;
	static MyArrayList g[];
	static int cnt,wowcnt;
	static int first[], depth[], dfs_order[], logs[], parent[];
	static int wowOrdering[];
	static int subtreeSize[];
	static int z[][];
	static int dist[];

	public static void main(String args[]) {
		InputReader in = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		n = in.nextInt();
		t = in.nextInt();

		g = new MyArrayList[n];
		for (int i = 0; i < n; i++)
			g[i] = new MyArrayList();

		for (int i = 1; i < n; i++) {
			int u = in.nextInt() - 1;
			int v = in.nextInt() - 1;
			int c = in.nextInt();
			g[u].add(v);
			g[u].add(c);
			g[v].add(u);
			g[v].add(c);
		}

		preprocess();
		
		while (t-- > 0) {
			k = in.nextInt();
			if (k >= magic) {
				subtreeSize = new int[n];
				for (int i = 0; i < k; i++)
					subtreeSize[in.nextInt() - 1]++;
				w.println(dfs2());
			} else {
				long ans = 0;
				int x[] = new int[k];
				for (int i = 0; i < k; i++) {
					x[i] = in.nextInt() - 1;
					for (int j = 0; j < i; j++)
						ans += query(x[i], x[j]);
				}
				w.println(ans);
			}
		}

		w.close();
	}

	static long dfs2() {
		long ans = 0;
		for(int i=n-1;i>=0;i--){
			int s = g[i].size();
			for(int j=0;j<s;){
				int next = g[i].get(j++);
				int edge = g[i].get(j++);
				if(next == parent[i])	continue;
				ans += subtreeSize[next] * 1L * (k - subtreeSize[next]) * edge;
				subtreeSize[i] += subtreeSize[next];
			}
		}
		return ans;
	}

	static void preprocess() {
		depth = new int[n];
		dfs_order = new int[2 * n - 1];
		dist = new int[n];
		wowOrdering = new int[n];
		parent = new int[n];
		cnt = wowcnt = 0;
		dfs(0, 0);
		buildLogs(2 * n - 1);
		buildSparseTableMin(2 * n - 1);
		first = new int[n];
		for (int i = 2 * n - 2; i >= 0; i--)
			first[dfs_order[i]] = i;
	}

	static void dfs(int curr, int prev) {
		dfs_order[cnt++] = curr;
		wowOrdering[wowcnt++] = curr;
		parent[curr] = prev;
		int s = g[curr].size();
		for (int i = 0; i < s;) {
			int next = g[curr].get(i++);
			int edge = g[curr].get(i++);
			if (next == prev)
				continue;
			depth[next] = depth[curr] + 1;
			dist[next] = dist[curr] + edge;
			dfs(next, curr);
			dfs_order[cnt++] = curr;
		}
	}

	static int query(int i, int j) {
		return dist[i] + dist[j] - (dist[lca(i, j)] << 1);
	}

	static int lca(int a, int b) {
		return queryMin(Math.min(first[a], first[b]),
				Math.max(first[a], first[b]));
	}

	public static void buildLogs(int n) {
		logs = new int[n + 1];
		int g = 2;
		while (g <= n) {
			logs[g] = 1;
			g = (g << 1);
		}
		for (int i = 1; i <= n; i++)
			logs[i] += logs[i - 1];
	}

	public static void buildSparseTableMin(int n) {
		int p, g;
		z = new int[19][n];
		for (int i = 0; i < n; i++)
			z[0][i] = dfs_order[i];
		for (int j = 1; (1 << j) < n; j++) {
			for (int i = 0; i + (1 << j) <= n; i++) {
				g = depth[z[j - 1][i]];
				p = depth[z[j - 1][i + (1 << (j - 1))]];
				z[j][i] = g < p ? z[j - 1][i] : z[j - 1][i + (1 << (j - 1))];
			}
		}
	}

	public static int queryMin(int l, int r) {
		int k = logs[r - l + 1];
		return depth[z[k][l]] <= depth[z[k][r - (1 << k) + 1]] ? z[k][l] : z[k][r - (1 << k) + 1];
	}

	static public class MyArrayList {

		private int[] myStore;
		private int actSize = 0;

		public MyArrayList() {
			myStore = new int[2];
		}

		public int get(int index) {
			return myStore[index];
		}

		public void add(int obj) {
			if (myStore.length - actSize <= 1)
				increaseListSize();
			myStore[actSize++] = obj;
		}

		public int size() {
			return actSize;
		}

		private void increaseListSize() {
			myStore = Arrays.copyOf(myStore, myStore.length * 2);
		}
	}

	static class InputReader {

		private InputStream stream;
		private byte[] buf = new byte[8192];
		private int curChar;
		private int snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));

			return res;
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}

}