[Ipsc2015]Generating Synergy K-D tree

NKOJ 4345 Generating Synergy

问题描述

给定一棵以1为根的有根树,初始所有节点颜色为1,每次将距离节点a不超过l的a的子节点染成c,或询问点a的颜色

输入格式

第一行一个数T,表示数据组数
接下来每组数据的第一行三个数n,c,q表示结点个数,颜色数和操作数
接下来一行n-1个数描述2..n的父节点
接下来q行每行三个数a,l,c
若c为0,表示询问a的颜色
否则将距离a不超过l的a的子节点染成c

输出格式

设当前是第i个操作,y_i为本次询问的答案(若本次操作是一个修改则y_i为0),令z_i=i*y_i,请输出z_1+z_2+…+z_q模10^9+7

样例输入

1
4 3 7
1 2 2
3 0 0
2 1 3
3 0 0
1 0 2
2 0 0
4 1 1
4 0 0

样例输出

32

数据范围

对于100%的数据T<=6,n,m,c<=10^5,
1<=a<=n,0<=l<=n,0<=c<=c

---

单点查询不是问题，对于多点修改，显然想把它转换为区间修改，这样才能通过打标记保证时间复杂度。

首先容易想到处理“距离不超过l”就用深度就可以搞定了。那么还需要“在子树内”的条件。用DFS序就可以方便地知道一个节点管辖的范围。

因此，如果把每个树上的节点对应为二维空间里的点$(In[x],dep[x])$，每次修改的就是横坐标在$[In[x],Out[x]]$，纵坐标在$[dep[x],dep[x]+l]$的点，是一个矩形区间。可以用树套树，但是K-D tree更易于实现。

注意修改操作与线段树不同，与平衡树相似：节点本身就代表了一个点。而线段树则是只有底层代表了原来的点。

---

#include<stdio.h>
#include<algorithm>
#include<cstring>
#define MAXN 100005
#define MAXM 200005
#define ll long long
#define Max(x,y) ((x>y)?(x):(y))
#define Min(x,y) ((x<y)?(x):(y))
using namespace std;

const ll mod=1e9+7;

int N,C,Q,Hash[MAXN];

int D;

struct node{
    int d[2],x[2],y[2],son[2],c,id,lazy;
    bool operator<(const node &x)const{return d[D]<x.d[D];}
}A[MAXN],T[MAXN];

int en[MAXM],nex[MAXM],las[MAXN],Tot;
void Add(int x,int y)
{
    en[++Tot]=y;
    nex[Tot]=las[x];
    las[x]=Tot;
}

int VT,In[MAXN],Out[MAXN],dep[MAXN];
void DFS(int x,int f)
{
    int i,y;

    In[x]=++VT;dep[x]=dep[f]+1;
    for(i=las[x];i;i=nex[i])
    {
        y=en[i];
        if(y!=f)DFS(y,x);
    }
    Out[x]=VT;
}

void Update(int p,int s)
{
    T[p].x[0]=Min(T[p].x[0],T[s].x[0]);
    T[p].x[1]=Max(T[p].x[1],T[s].x[1]);
    T[p].y[0]=Min(T[p].y[0],T[s].y[0]);
    T[p].y[1]=Max(T[p].y[1],T[s].y[1]);
}

void Putdown(int p)
{
    int ls=T[p].son[0],rs=T[p].son[1];
    if(ls)T[ls].c=T[ls].lazy=T[p].lazy;
    if(rs)T[rs].c=T[rs].lazy=T[p].lazy;
    T[p].lazy=0;
}

int tot;
int Build(int l,int r,int d)
{
    D=d;
    int p=++tot,mid=l+r>>1;
    nth_element(A+l,A+mid,A+r+1);
    T[p].d[0]=T[p].x[0]=T[p].x[1]=A[mid].d[0];
    T[p].d[1]=T[p].y[0]=T[p].y[1]=A[mid].d[1];
    T[p].c=1;T[p].lazy=0;
    if(l<mid)T[p].son[0]=Build(l,mid-1,d^1),Update(p,T[p].son[0]);else T[p].son[0]=0;
    if(r>mid)T[p].son[1]=Build(mid+1,r,d^1),Update(p,T[p].son[1]);else T[p].son[1]=0;
    return p;
}

int check(int p,int l,int r,int u,int d)
{
    if(T[p].x[0]>=l&&T[p].x[1]<=r&&T[p].y[0]>=d&&T[p].y[1]<=u)return 2;
    if(T[p].x[0]>r||T[p].x[1]<l||T[p].y[0]>u||T[p].y[1]<d)return 0;
    return 1;
}

void Modify(int p,int l,int r,int u,int d,int k)
{
    if(T[p].lazy)Putdown(p);
    int ck=check(p,l,r,u,d);
    if(ck==2){T[p].lazy=k;T[p].c=k;return;}
    if(ck==0)return;
    if(T[p].d[0]>=l&&T[p].d[0]<=r&&T[p].d[1]<=u&&T[p].d[1]>=d)T[p].c=k;
    if(T[p].son[0])Modify(T[p].son[0],l,r,u,d,k);
    if(T[p].son[1])Modify(T[p].son[1],l,r,u,d,k);
}

int Ans;
void Query(int p,int x,int y,int d)
{
    if(Ans)return;
    if(T[p].lazy)Putdown(p);
    if(T[p].d[0]==x&&T[p].d[1]==y){Ans=T[p].c;return;}
    int ls=T[p].son[0],rs=T[p].son[1];
    if(d)
    {
        if(ls&&T[ls].x[0]<=x&&T[ls].x[1]>=x)Query(ls,x,y,d^1);
        if(rs&&T[rs].x[0]<=x&&T[rs].x[1]>=x)Query(rs,x,y,d^1);
    }
    else
    {
        if(ls&&T[ls].y[0]<=y&&T[ls].y[1]>=y)Query(ls,x,y,d^1);
        if(rs&&T[rs].y[0]<=y&&T[rs].y[1]>=y)Query(rs,x,y,d^1);
    }
}

ll TotAns;
void Clear()
{
    VT=0;
    memset(las,0,sizeof(las));Tot=0;
    tot=0;
    TotAns=0;
}

int main()
{
    int t;

    scanf("%d",&t);
    while(t--)
    {
        Clear();

        int i,x,y,op;

        scanf("%d%d%d",&N,&C,&Q);
        for(i=2;i<=N;i++)scanf("%d",&x),Add(x,i);

        DFS(1,0);

        for(i=1;i<=N;i++)A[i].d[0]=In[i],A[i].d[1]=dep[i];

        Build(1,N,0);

        for(i=1;i<=Q;i++)
        {
            scanf("%d%d%d",&x,&y,&op);
            if(op==0)
            {
                Ans=0;
                Query(1,In[x],dep[x],0);
                TotAns=(TotAns+1ll*Ans*i)%mod;
            }
            else Modify(1,In[x],Out[x],dep[x]+y,dep[x],op);
        }

        printf("%lld\n",TotAns);
    }
}