就是直接线段树合并。

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

int n, m;
vector<int> e[N];

int idx;
int rt[N];
int ans[N];
struct Node {
    int lson, rson;
    int maxn, col;
} tr[N * 80];

void pushup(int u) {
    if (tr[tr[u].lson].maxn > tr[tr[u].rson].maxn) {
        tr[u].maxn = tr[tr[u].lson].maxn;
        tr[u].col = tr[tr[u].lson].col;
    } else if (tr[tr[u].lson].maxn < tr[tr[u].rson].maxn) {
        tr[u].maxn = tr[tr[u].rson].maxn;
        tr[u].col = tr[tr[u].rson].col;
    } else {
        if (tr[tr[u].lson].col < tr[tr[u].rson].col) {
            tr[u].maxn = tr[tr[u].lson].maxn;
            tr[u].col = tr[tr[u].lson].col;
        } else {
            tr[u].maxn = tr[tr[u].rson].maxn;
            tr[u].col = tr[tr[u].rson].col;
        }
    }
}

void modify(int &u, int l, int r, int d, int x) {
    if (!u) u = ++idx;
    if (l == r) {
        tr[u].maxn += x;
        tr[u].col = l;
        return;
    }

    int mid = (l + r) >> 1;

    if (d <= mid) modify(tr[u].lson, l, mid, d, x);
    else modify(tr[u].rson, mid + 1, r, d, x);

    pushup(u);
}

int merge(int u, int v, int l, int r) {
    if (!u) return v;
    if (!v) return u;

    if (l == r) {
        tr[u].maxn += tr[v].maxn;
        tr[u].col = l;
        return u;
    }

    int mid = (l + r) >> 1;

    tr[u].lson = merge(tr[u].lson, tr[v].lson, l, mid);
    tr[u].rson = merge(tr[u].rson, tr[v].rson, mid + 1, r);

    pushup(u);

    return u;
}

void solve(int u, int fa = -1) {
    for (auto v : e[u]) {
        if (v == fa) continue;

        solve(v, u);

        merge(rt[u], rt[v], 1, 100000);
    }

    ans[u] = tr[rt[u]].col;
}

int idx_dfn;
int fa[N], dep[N], top[N], son[N], sz[N], dfn[N];

void dfs1(int u, int f = 0) {
    dep[u] = dep[f] + 1;
    sz[u] = 1;
    fa[u] = f;
 
    for (auto v : e[u]) {
        if (v == f) continue;

        dfs1(v, u);

        sz[u] += sz[v];
        if (sz[son[u]] < sz[v]) son[u] = v;
    }
}

void dfs2(int u, int topf) {
    dfn[u] = ++idx_dfn;
    top[u] = topf;

    if (son[u])
        dfs2(son[u], topf);

    for (auto v : e[u]) if (v != son[u] && v != fa[u])
        dfs2(v, v);
}

int LCA(int u, int v) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }

    if (dep[u] > dep[v]) swap(u, v);

    return u;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i < n; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        e[u].push_back(v);
        e[v].push_back(u);
        rt[i] = i;
    }
    idx = n;

    dfs1(1, 0), dfs2(1, 1);

    for (int i = 1; i <= m; ++i) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        modify(rt[u], 1, 100000, w, 1);
        modify(rt[v], 1, 100000, w, 1);
        // cout << LCA(u, v) << "---\n";
        if (LCA(u, v) != 1)
            modify(rt[fa[LCA(u, v)]], 1, 100000, w, -2);
    }

    solve(1);

    for (int i = 1; i <= n; ++i) printf("%d\n", ans[i]);

    return 0;
}