#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <utility>
#include <queue>
#include <map>
#include <cstring>
using namespace std;

#define MAXN 100005

struct Node {
    long long own_value;
    int parent_idx;
    int dist_to_parent;
    vector<int> child_idx;
    long long sum_child; // with own value
};

bool isCalled[MAXN];
int num_child[MAXN];
Node nodes[MAXN];
long long global_sum = 0;

int main() {
    int N, T, parent_id;
    queue<int> q;
    
    for (int i = 0; i < MAXN; i++) isCalled[i] = false;
    scanf("%d %d", &N, &T);
    
    for (int i = 1; i < N; i++) {
        int A, B, C;
        scanf("%d %d %d", &A, &B, &C);
        if (i == 1) {
            parent_id = A;
            isCalled[A] = true;
            nodes[A].parent_idx = 0;
        }
        if (!isCalled[B]) { // v is the child of u
            isCalled[B] = true;
            nodes[A].child_idx.push_back(B); // store as child
            nodes[B].parent_idx = A;
            nodes[B].dist_to_parent = C;
        } else if (!isCalled[A]) { // u is the child of v
            isCalled[A] = true;
            nodes[B].child_idx.push_back(A); // store as child
            nodes[A].parent_idx = B;
            nodes[A].dist_to_parent = C;
        }
    }
    
    // Process tree here
    vector<int> leaf_nodes;
    for (int i = 1; i <= N; i++) {
        num_child[i] = nodes[i].child_idx.size();
        if (num_child[i] == 0) leaf_nodes.push_back(i); // leaf nodes
    }
    
    for (int i = 0; i < T; i++) {
        int K;
        long long ans = 0;
        global_sum = 0;
        scanf("%d", &K);
        map<int, int> m;
        for (int i = 1; i <= N; i++) {
            num_child[i] = nodes[i].child_idx.size();
            nodes[i].own_value = 0;
            nodes[i].sum_child = 0;
        }
        for (int j = 0; j < K; j++) {
            int temp;
            scanf("%d", &temp);
            nodes[temp].own_value++;

        }
        for (int j = 0; j < leaf_nodes.size(); j++)
            q.push(leaf_nodes[j]);
        // Pre-compute
        while (!q.empty()) {
            int cur = q.front();
            q.pop();

            // At this point, num_child from cur is 0
            nodes[cur].sum_child += nodes[cur].own_value;

            // Add this sum to parent
            int parent = nodes[cur].parent_idx;
            if (parent != 0) {
                nodes[parent].sum_child += nodes[cur].sum_child;
                num_child[parent]--;
                if (num_child[parent] == 0) q.push(parent);
            }
        }
        // Calculate distance
        for (int i = 1; i <= N; i++) {
            if (parent_id != i) {
                long long this_side = nodes[i].sum_child;
                long long other_side = K - this_side;
                ans += (long long) nodes[i].dist_to_parent * this_side * other_side;
            }
        }

        printf("%lld\n", ans);
    }
    
    return 0;
}
/** Created by freedomofkeima */