LWDB

题意：

给一棵 $n$ 个节点的树，维护两种操作：

　　1.将距离 $x$ $distance \leq d$ 的点染成 $c$

　　2.询问 $x$ 的颜色。

解法：

首先将染色可以转换为每个时间对应一个颜色，问题转化为区间取 $max$

动态树分治，即可。

考虑朴素点分治中的每一个重心，将其管辖的所有点按照到重心的距离从大到小排序，然后用线段树维护。

修改时，从 $x$ 向上走，将每一个重心 $t$ 中 $dist<x,t> + dist<t,y>\leq d$ 的点修改。

查找时，从 $x$ 向上走，查询每一个重心中 $x$ 所对应的值，求 $max$ 即可。

$O(nlog^2n)$

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
 
#define p E[i].x
#define N 100010
#define M 7000010
#define l(x) ch[x][0]
#define r(x) ch[x][1]
#define MP(x, y) make_pair(x, y)
#define LL long long
 
using namespace std;
 
typedef pair<int,int> PII;
 
struct edge
{
    int x, to, v;
}E[N<<];
 
int totE, totn, n, m, hev, lef_now;
int g[N], h[N], de[N], siz[N], root[N], fa[N][], col[N], d[N];
int ch[M][], setv[M];
vector<PII> nod[N], id[N];
vector<int> hevs[N];
int dis[N][];
bool v[N];
 
void addedge(int x, int y, int v)
{
    E[++totE] = (edge){y, g[x], v}; g[x] = totE;
}
 
int build(int l, int r)
{
    int x = ++totn;
    setv[x] = ;
    if(l == r) return x;
    int mid = (l+r)>>;
    l(x) = build(l, mid);
    r(x) = build(mid+, r);
    return x;
}
 
void push(int x)
{
    if(!setv[x]) return;
    setv[l(x)] = setv[x];
    setv[r(x)] = setv[x];
    setv[x] = ;
}
 
int ask(int x, int l, int r, int qx)
{
    if(l<r) push(x);
    if(l == r) return setv[x];
    int mid = (l+r)>>;
    if(qx <= mid) return ask(l(x), l, mid, qx);
    else return ask(r(x), mid+, r, qx);
}
 
void change(int x, int l, int r, int ql, int qr, int qv)
{
    if(l<r) push(x);
    if(ql<=l && r<=qr)
    {
        setv[x] = qv;
        return;
    }
    int mid=(l+r)>>;
    if(ql <= mid) change(l(x),l,mid,ql,qr,qv);
    if(mid < qr) change(r(x),mid+,r,ql,qr,qv);
}
 
int dist(int x, int y)
{
    if(de[x] < de[y]) swap(x, y);
    int ans = ;
    for(int i = ;~i;i--)
        if(de[fa[x][i]] >= de[y]) ans += dis[x][i], x = fa[x][i];
    if(x == y) return ans;
    for(int i = ;~i;i--)
        if(fa[x][i] != fa[y][i])
        {
            ans += dis[x][i]; x = fa[x][i];
            ans += dis[y][i]; y = fa[y][i];
        }
    return ans+dis[x][]+dis[y][];
}
 
void dfs1(int x, int tmp)
{
    siz[x] = ;
    h[x] = ;
    for(int i = g[x];i;i = E[i].to)
        if(!v[p] && p != tmp)
        {
            dfs1(p, x);
            h[x] = max(h[x], siz[p]);
            siz[x] += siz[p];
        }
    h[x] = max(h[x], lef_now - siz[x]);
    if(!hev || h[x] < h[hev]) hev = x;
}
 
void dfs(int x)
{
    for(int i = g[x];i;i = E[i].to)
        if(p != fa[x][])
        {
            fa[p][] = x;
            dis[p][] = E[i].v;
            de[p] = de[x] + ;
            dfs(p);
        }
}
 
void dfs2(int x, int tmp, int now)
{
    nod[now].push_back(MP(d[x], x));
    for(int i = g[x];i;i = E[i].to)
        if(!v[p] && p != tmp)
        {
            d[p] = d[x] + E[i].v;
            dfs2(p, x, now);
        }
}
 
void solve(int x)
{
    v[x] = ;
    d[x] = ;
    dfs2(x, x, x);
    sort(nod[x].begin(), nod[x].end());
    for(int i = ;i < (int)nod[x].size();i++)
    {
        id[x].push_back( MP(nod[x][i].second, i) );
        hevs[nod[x][i].second].push_back(x);
    }
    sort(id[x].begin(), id[x].end());
    root[x] = build(, nod[x].size()-);
    for(int i = g[x];i;i = E[i].to)
        if(!v[p])
        {
            hev = ;
            lef_now = siz[p];
            dfs1(p, x);
            solve(hev);
        }
}
 
int find(int x,int len)
{
    int l=,r=nod[x].size()-;
    while(r-l>)
    {
        int mid = (l+r)>>;
        if(nod[x][mid].first <= len) l=mid;
        else r=mid;
    }
    for(int i=r;i>=l;i--)
        if(nod[x][i].first <= len) return i;
    return -;
}
 
void com_change(int x, int len, int v)
{
    for(int i = ;i < (int)hevs[x].size();i++)
    {
        int tmp = hevs[x][i];
        int t = find(tmp, len - dist(x, tmp));
        if(t == -) continue;
        change(root[tmp], , id[tmp].size()-, , t, v);
    }
}
 
int com_ask(int x)
{
    int ans = ;
    for(int i = ;i < (int)hevs[x].size();i++)
    {
        int tmp = hevs[x][i];
        int t = (*lower_bound(id[tmp].begin(), id[tmp].end(), MP(x, -))).second;
        ans = max(ans, ask(root[tmp], , id[tmp].size()-, t));
    }
    return col[ans];
}
 
int main()
{
    scanf("%d", &n);
    for(int i = , x, y, v;i < n;i++)
    {
        scanf("%d %d %d", &x, &y, &v);
        addedge(x, y, v);
        addedge(y, x, v);
    }
    de[]=;
    dfs();
    for(int j = ;j <= ;j++)
    {
        for(int i = ;i <= n;i++)
        {
            fa[i][j] = fa[fa[i][j-]][j-];
            dis[i][j] = dis[fa[i][j-]][j-] + dis[i][j-];
        }
    }
    totn = ;
    hev = ;
    lef_now = n;
    dfs1(, );
    solve(hev);
    scanf("%d", &m);
    int x,cmd,len,tot=;
    while(m--)
    {
        scanf("%d%d",&cmd,&x);
        if(cmd==)
        {
            scanf("%d%d",&len,&col[++tot]);
            com_change(x,len,tot);
        }
        else printf("%d\n",com_ask(x));
    }
    return ;
}