题面
深绘里一直很讨厌雨天。
灼热的天气穿透了前半个夏天，后来一场大雨和随之而来的洪水，浇灭了一切。
虽然深绘里家乡的小村落对洪水有着顽固的抵抗力，但也倒了几座老房子，几棵老树被连根拔起，以及田地里的粮食被弄得一片狼藉。
无奈的深绘里和村民们只好等待救济粮来维生。
不过救济粮的发放方式很特别。
有 n 个点，形成一个树状结构。
有 m 次发放操作，每次选择两个点 x,y，对 x 到 y 的路径上（包括 x,y）的每个点发放一袋 z 类型的物品。
求完成所有发放操作后，每个点存放最多的是哪种类型的物品。
输入格式
第一行两个正整数n,m，含义如题目所示。
接下来n-1行，每行两个数(a,b)，表示(a,b)间有一条边。
再接下来m行，每行三个数(x,y,z)，含义如题目所示。
输出格式
共n行，第i行一个整数，表示第i座房屋里存放的最多的是哪种救济粮，如果有多种救济粮存放次数一样，输出编号最小的。
如果某座房屋里没有救济粮，则对应一行输出0。
数据范围
1≤n,m≤100000,
1≤z≤10^9
输入样例：
5 3
1 2
3 1
3 4
5 3
2 3 3
1 5 2
3 3 3
输出样例：
2
3
3
0
2
题解
需要掌握 树上LCA 和 动态开点线段树
思想 差分, 离散化
根据题意明显是 区间操作, 对于树, 那么就是树上差分 和 树剖 了
对于 (x, y) 增加 z, 根据差分, 思考发现, ++val[x][z], ++val[y][z], --val[lca(x, y)][z], --val[lca(x, y)的父节点][z], 可以在树上线性跑出 每个节点 z 的数量
而 z 异常的大, 1e9, 而 m 只有1e5, 明显需要离散化, 降低 z 的范围
就算如此 对于每个节点 跑出 每个z的数量也是 爆炸的
我们就要想到 log 级别的方法, 那就线段树了, 然而肯定会爆内存, 所以要动态开点
对于节点数, 4 * m * log2(z(离散化)), 每个节点占 12字节, 在加上乱七八糟的lca和存输入的数组, 内存也不会太紧张(你要是节点东西多了, 会爆, 还是有点卡内存的)
#include <bits/stdc++.h>
#define all(n) (n).begin(), (n).end()
#define se second
#define fi first
#define pb push_back
#define mp make_pair
#define sqr(n) (n)*(n)
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define per(i,a,b) for(int i=(a);i>=(b);--i)
#define IO ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef vector<int> VI;
typedef double db;
const int N = 1e5 + 5, M = 7e6 + 5;
int n, m, _, k;
int h[N], ne[N << 1], to[N << 1], tota;
int dep[N], f[N][20], t;
int x[N], y[N], z[N], tax[N], tot, ans[N];
void add(int u, int v) {
ne[++tota] = h[u]; to[h[u] = tota] = v;
}
void bfs(int s) {
queue<int> q;
q.push(s); dep[s] = 1;
rep(i, 0, t) f[s][i] = 0;
while (!q.empty()) {
int x = q.front(); q.pop();
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
if (dep[y]) continue;
dep[y] = dep[x] + 1;
f[y][0] = x;
for (int j = 1; j <= t; ++j)
f[y][j] = f[f[y][j - 1]][j - 1];
q.push(y);
}
}
}
int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
per(i, t, 0)
if (dep[f[y][i]] >= dep[x]) y = f[y][i];
if (x == y) return x;
per(i, t, 0)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
struct Node {
int l, r, mx;
} tr[M];
int node, rt[N];
void push_up(int root) {
tr[root].mx = max(tr[tr[root].l].mx, tr[tr[root].r].mx);
}
void update(int& root, int l, int r, int val, int d) {
if (root == 0) root = ++node;
if (l == r) {
tr[root].mx += d;
return;
}
int mid = (l + r) >> 1;
if (mid >= val) update(tr[root].l, l, mid, val, d);
else update(tr[root].r, mid + 1, r, val, d);
push_up(root);
}
int merge(int a, int b) {
if (a == 0 || b == 0) return a | b;
if (tr[a].l == 0 && tr[a].r == 0) {
tr[a].mx += tr[b].mx;
return a;
}
tr[a].l = merge(tr[a].l, tr[b].l);
tr[a].r = merge(tr[a].r, tr[b].r);
push_up(a);
return a;
}
int query(int root, int l, int r) {
if (root == 0) return 0;
if (l == r) return l;
int mid = (l + r) >> 1;
if (tr[tr[root].l].mx == tr[root].mx) return query(tr[root].l, l, mid);
else return query(tr[root].r, mid + 1, r);
}
void dfs(int u, int fa) {
for (int i = h[u]; i; i = ne[i]) {
int y = to[i];
if (y == fa) continue;
dfs(y, u);
rt[u] = merge(rt[u], rt[y]);
}
ans[u] = tax[query(rt[u], 1, tot)];
}
int main() {
IO; cin >> n >> m;
t = log2(n - 1) + 1;
rep(i, 2, n) {
int u, v; cin >> u >> v;
add(u, v); add(v, u);
}
bfs(1);
rep(i, 1, m) cin >> x[i] >> y[i] >> z[i], tax[i] = z[i];
sort(tax + 1, tax + 1 + m);
tot = unique(tax + 1, tax + 1 + m) - tax - 1;
rep(i, 1, m) {
int fa = lca(x[i], y[i]), c = lower_bound(tax + 1, tax + tot + 1, z[i]) - tax;
update(rt[x[i]], 1, tot, c, 1); update(rt[y[i]], 1, tot, c, 1);
update(rt[fa], 1, tot, c, -1); update(rt[f[fa][0]], 1, tot, c, -1);
}
dfs(1, 0);
rep(i, 1, n) cout << ans[i] << '
';
return 0;
}