BZOJ 4154

    感觉这个题的思想还是很妙的，刚开始看这道题的时候大概会向一些树的算法比如树链剖分或是主席树维护深度之类的方向去想，但是我们考虑它实际上是一个二维数点的问题，由于是子树的修改，我们很自然的会想到用DFS序来搞，那么对于一个子树深度不超过定值的所有点就被包含在了一个矩形中，这样我们就可以用KD_tree来进行矩形的赋值，单点查询了，这个我不知道可不可以用树套树来做，如果哪位神犇会用树套树来搞的话，请留言指导一下蒟蒻。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 100005
typedef long long LL;
const int mo=1000000007;
int pre[maxn],last[maxn],other[maxn];
int st[maxn],en[maxn],dep[maxn];
int n,m,q,l,T,tot,rt,cmp_d,now[2];
LL ans;
struct KD_tree
{
    int ls,rs;
    int d[2],mn[2],mx[2];
    int col,lazy;
}t[maxn];
 
inline int read(void)
{
    int x=0;
    char ch=getchar();
    while (ch>'9'||ch<'0') ch=getchar();
    while (ch>='0'&&ch<='9')
    {
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x;
}
 
void connect(int x,int y)
{
    l++;
    pre[l]=last[x];
    last[x]=l;
    other[l]=y;
}
 
void dfs(int u)
{
    st[u]=++tot;
    for (int p=last[u];p;p=pre[p])
    {
        int v=other[p];
        dep[v]=dep[u]+1;
        dfs(v);
    }
    en[u]=tot;
}
 
inline bool cmp(KD_tree a,KD_tree b)
{
    int x=a.d[cmp_d],y=b.d[cmp_d];
    return x<y||(x==y&&a.d[!cmp_d]<b.d[!cmp_d]);
}
 
void KD_update(int x)
{
    int ls=t[x].ls;
    int rs=t[x].rs;
    if (ls) 
    {
        t[x].mn[0]=min(t[x].mn[0],t[ls].mn[0]);
        t[x].mx[0]=max(t[x].mx[0],t[ls].mx[0]);
        t[x].mn[1]=min(t[x].mn[1],t[ls].mn[1]);
        t[x].mx[1]=max(t[x].mx[1],t[ls].mx[1]);
    }
    if (rs)
    {
        t[x].mn[0]=min(t[x].mn[0],t[rs].mn[0]);
        t[x].mx[0]=max(t[x].mx[0],t[rs].mx[0]);
        t[x].mn[1]=min(t[x].mn[1],t[rs].mn[1]);
        t[x].mx[1]=max(t[x].mx[1],t[rs].mx[1]);
    }
}
 
int KD_build(int l,int r,int D)
{
    int mid=(l+r)>>1;
    cmp_d=D;
    nth_element(t+l,t+mid,t+r+1,cmp);
    t[mid].mn[0]=t[mid].mx[0]=t[mid].d[0];
    t[mid].mn[1]=t[mid].mx[1]=t[mid].d[1];
    t[mid].col=1;t[mid].lazy=0;
    t[mid].ls=t[mid].rs=0;
    if (l<mid) t[mid].ls=KD_build(l,mid-1,D^1);
    if (r>mid) t[mid].rs=KD_build(mid+1,r,D^1);
    KD_update(mid);
    return mid;
}
 
inline void push_down(int x)
{
    if (!t[x].lazy) return;
    int ls=t[x].ls,rs=t[x].rs;
    if (ls) t[ls].col=t[ls].lazy=t[x].lazy;
    if (rs) t[rs].col=t[rs].lazy=t[x].lazy;
    t[x].lazy=0;
}
 
int KD_ask(int x,int D)
{
    if (t[x].d[0]==now[0]&&t[x].d[1]==now[1]) return t[x].col;
    push_down(x);
    if (now[D]<t[x].d[D]||(now[D]==t[x].d[D]&&now[!D]<t[x].d[!D]))
        return KD_ask(t[x].ls,D^1);
    else
        return KD_ask(t[x].rs,D^1);
}
 
inline pair<bool,bool> in(int x,int x1,int y1,int x2,int y2)
{
    bool p1= t[x].mn[0]>=x1&&t[x].mx[0]<=x2&&t[x].mn[1]>=y1&&t[x].mx[1]<=y2;
    bool p2= t[x].d[0]>=x1&&t[x].d[0]<=x2&&t[x].d[1]>=y1&&t[x].d[1]<=y2;
    return make_pair(p1,p2);
}
 
inline bool out(int x,int x1,int y1,int x2,int y2)
{
    return t[x].mx[0]<x1||t[x].mn[0]>x2||t[x].mx[1]<y1||t[x].mn[1]>y2;
}
 
void KD_add(int x,int x1,int y1,int x2,int y2,int c)
{
    if (!x) return;
    push_down(x);
    if (in(x,x1,y1,x2,y2).first) 
    {
        t[x].col=t[x].lazy=c;
        return;
    }
    if (out(x,x1,y1,x2,y2)) return;
    if (in(x,x1,y1,x2,y2).second) t[x].col=c;
    KD_add(t[x].ls,x1,y1,x2,y2,c);
    KD_add(t[x].rs,x1,y1,x2,y2,c);
}
 
int main()
{
    T=read();
    while (T--) 
    {
        memset(last,0,sizeof last);l=tot=0;
        n=read();m=read();q=read();
        for (int i=2;i<=n;i++)
        {
            int fa=read();
            connect(fa,i);
        }
        dfs(1);
        for (int i=1;i<=n;i++) t[i].d[0]=st[i],t[i].d[1]=dep[i];
        rt=KD_build(1,n,0);
        ans=0;
        for (int i=1;i<=q;i++) 
        {
            int x=read(),y=read(),c=read();
            if (c==0) 
            {
                now[0]=st[x];now[1]=dep[x];
                y=KD_ask(rt,0);
                ans=(ans+(LL)y*i)%mo;
            }
            else
            {
                int x1=st[x],y1=dep[x];
                int x2=en[x],y2=dep[x]+y;
                KD_add(rt,x1,y1,x2,y2,c);
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}