OI XXX - zbo

// https://szkopul.edu.pl/problemset/problem/mTIclw457_QBtRPC4pG2tgg7/site/?key=statement

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

#define int int64_t

constexpr int sizik = 100 * 1001;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

std::vector<std::pair<int, int>> kra[sizik];

constexpr int sizik2 = 18;

int depth[sizik];

int first_occ[sizik];
int euler_tour[2 * sizik];
int st[2 * sizik][sizik2 + 1];
int lg[2 * sizik];
int tour_idx = 0;

void DFS_prep(int v, int p, int d) {
    depth[v] = d;
    euler_tour[++tour_idx] = v;
    first_occ[v] = tour_idx;
    for (const auto& [u, c] : kra[v]) {
        if (u == p) continue;
        DFS_prep(u, v, d + c);
        euler_tour[++tour_idx] = v;
    }
}

void build_lca() {
    lg[1] = 0;
    for (int i = 2; i <= tour_idx; i++)
        lg[i] = lg[i / 2] + 1;

    for (int i = 1; i <= tour_idx; i++)
        st[i][0] = euler_tour[i];

    for (int j = 1; j <= sizik2; j++) {
        for (int i = 1; i + (1 << j) - 1 <= tour_idx; i++) {
            int u = st[i][j - 1];
            int v = st[i + (1 << (j - 1))][j - 1];
            st[i][j] = (depth[u] < depth[v]) ? u : v;
        }
    }
}

inline int lca(int u, int v) {
    if (u == v) return u;

    int L = first_occ[u];
    int R = first_occ[v];

    if (L > R) std::swap(L, R);

    int j = lg[R - L + 1];
    int u_res = st[L][j];
    int v_res = st[R - (1 << j) + 1][j];

    return (depth[u_res] < depth[v_res]) ? u_res : v_res;
}

inline int dist(int a, int b) {
    if (a == b) return 0;
    int L = lca(a, b);
    return depth[a] + depth[b] - 2 * depth[L];
}

std::bitset<sizik> active;
int A = 0;
int cnt1[sizik];

constexpr int S = 250;
int n, k;

void DFS_cnt(int v, int p) {
    cnt1[v] = (active[v]);
    for (const auto& [u, _] : kra[v]) {
        if (u == p) continue;
        DFS_cnt(u, v);
        cnt1[v] += cnt1[u];
    }
}

int qost[sizik];

void DFS_qost(int v, int p) {
    for (const auto& [u, c] : kra[v]) {
        if (u == p) continue;
        qost[u] = qost[v] + c * (A - 2 * cnt1[u]);
        DFS_qost(u, v);
    }
}

void prep() {
    DFS_cnt(1, 1);
    qost[1] = 0;
    for (int i = 2; i <= n; i++) {
        if (active[i]) {
            qost[1] += depth[i];
        }
    }
    DFS_qost(1, 1);
}

void solve() {
    std::cin >> n >> k;

    for (int i = 0; i < n - 1; i++) {
        int a, b, c;
        std::cin >> a >> b >> c;

        kra[a].push_back({b, c});
        kra[b].push_back({a, c});
    }

    active[1] = 1;
    DFS_prep(1, 1, 0);
    build_lca();
    A = 1;

    std::vector<int> curr;
    curr.reserve(S + 1);
    prep();
    int64_t prev = 0;
    for (; k > 0; k--) {
        int a;
        std::cin >> a;

        if (curr.size() >= S) {
            for (const auto& b : curr) {
                assert(active[b] == 0);
                A++;
                active[b] = 1;
            }
            curr.clear();
            prep();
        }

        int64_t wyn = 2 * qost[a];
        for (const auto& b : curr) {
            wyn += 2 * dist(a, b);
        }
        curr.push_back(a);
        int64_t t = prev;
        prev += wyn;
        wyn += t;

        std::cout << wyn << '\n';
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}