BZOJ 3307: 雨天的尾巴

用权值线段树维护最大值和其位置，树上差分作标记

再在树上线段树合并

这里有两个结论

• 树上差分后，子树中每个孩子的值之和就是当前节点的值
• 如果刚开始只有一个叶子节点的线段树有n个，那么合并成一棵线段树的复杂度为$O(nlogn)$

#include <bits/stdc++.h>
using namespace std;
 
#define N 100010
int n, q;
int x[N], y[N], z[N];
struct Graph
{
    struct node
    {
        int to, nx;
        node() {}
        node(int to, int nx) : to(to), nx(nx) {} 
    }a[N << 2];
    int head[N], pos;
    void add(int u, int v)
    {
        a[++pos] = node(v, head[u]); head[u] = pos;
        a[++pos] = node(u, head[v]); head[v] = pos;
    }
}G;
#define erp(u) for (int it = G.head[u], v = G.a[it].to; it; it = G.a[it].nx, v = G.a[it].to)
 
int b[N];
void Hash()
{
    b[0] = 0;
    for (int i = 1; i <= q; ++i) b[++b[0]] = z[i];
    sort(b + 1, b + 1 + b[0]);
    b[0] = unique(b + 1, b + 1 + b[0]) - b - 1;
    for (int i = 1; i <= q; ++i) z[i] = lower_bound(b + 1, b + 1 + b[0], z[i]) - b;  
}
 
int fa[N], deep[N], sze[N], son[N], top[N];
void DFS(int u)
{
    sze[u] = 1;
    erp(u) if (v != fa[u])
    {
        fa[v] = u;
        deep[v] = deep[u] + 1;
        DFS(v);
        sze[u] += sze[v];
        if (!son[u] || sze[v] > sze[son[u]]) son[u] = v;
    }
}
 
void getpos(int u, int sp)
{
    top[u] = sp;
    if (!son[u]) return;
    getpos(son[u], sp);
    erp(u) if (v != fa[u] && v != son[u])
        getpos(v, v);
}
 
int lca(int u, int v)
{
    while (top[u] != top[v])
    {
        if (deep[top[u]] < deep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    return deep[u] > deep[v] ? v : u;
}
 
namespace SEG
{
    #define M N * 70
    int T[N], lt[M], rt[M], Max[M], pos[M], cnt;
    void pushup(int now)
    {
        int ls = lt[now], rs = rt[now];
        if (Max[ls] >= Max[rs])
        {
            Max[now] = Max[ls];
            pos[now] = pos[ls];
        }
        else
        {
            Max[now] = Max[rs];
            pos[now] = pos[rs];
        }
    }
    void update(int &now, int l, int r, int loc, int v)
    {
        if (!now) now = ++cnt;
        if (l == r)
        {
            Max[now] += v;
            pos[now] = l; 
            return;
        }
        int mid = (l + r) >> 1;
        if (loc <= mid) update(lt[now], l, mid, loc, v);
        else update(rt[now], mid + 1, r, loc, v); 
        pushup(now);
    }
    int merge(int now, int pre, int l, int r)
    {
        if (!now | !pre) return now | pre;
        if (l == r)
        {
            Max[now] += Max[pre];
            pos[now] = l;
            return now;
        }
        int mid = (l + r) >> 1; 
        if (lt[now] | lt[pre]) lt[now] = merge(lt[now], lt[pre], l, mid); 
        if (rt[now] | rt[pre]) rt[now] = merge(rt[now], rt[pre], mid + 1, r);  
        pushup(now);
        return now;
    }
}
 
int ans[N];
void solve(int u)
{
    erp(u) if (v != fa[u]) 
    {
        solve(v);
        SEG::T[u] = SEG::merge(SEG::T[u], SEG::T[v], 1, b[0]);
    }
    int Pos = SEG::pos[SEG::T[u]];
    ans[u] = Pos ? b[Pos] : 0;
}

int main()
{
    while (scanf("%d%d", &n, &q) != EOF)
    {
        for (int i = 1, u, v; i < n; ++i)
        {
            scanf("%d%d", &u, &v);
            G.add(u, v);
        }
        fa[1] = 0; DFS(1); getpos(1, 1);
        for (int i = 1; i <= q; ++i) scanf("%d%d%d", x + i, y + i, z + i); Hash();
        for (int i = 1; i <= q; ++i)
        {
            int LCA = lca(x[i], y[i]);
            SEG::update(SEG::T[x[i]], 1, b[0], z[i], 1);
            SEG::update(SEG::T[y[i]], 1, b[0], z[i], 1);
            SEG::update(SEG::T[LCA], 1, b[0], z[i], -1);
            if (fa[LCA]) SEG::update(SEG::T[fa[LCA]], 1, b[0], z[i], -1);
        }
        solve(1);
        for (int i = 1; i <= n; ++i) printf("%d
", ans[i]);
    }
    return 0;
}