bzoj4154 [Ipsc2015]Generating Synergy

Description

---

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

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

Solution

---

非常巧妙的思想

把dfs序的位置看成横坐标，深度看成纵坐标，那么每个节点都是一个二维平面上的点，这样修改就是一个矩形打标记，单点查询
可以上树套树，也可以上kd树
注意虽然颜色一开始是1但是有可能变成其他颜色又变回1的情况，因此没有tag的lazy标记应该是0（听不懂可以跳过
膜标膜多了感觉自己啥都不会了只会查错了
PS: nth_element的确只有r要+1

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define fill(x,t) memset(x,t,sizeof(x))

typedef long long LL;
const int MOD=1000000007;
const int N=200005;
const int E=200005;

struct edge {int y,next;} e[E];
struct treeNode {int l,r,max[2],min[2],d[2],lazy,c;} t[N];

int size[N],dep[N],pos[N],dfn[N],D;
int ls[N],edCnt;

void add_edge(int x,int y) {
    e[++edCnt]=(edge) {y,ls[x]}; ls[x]=edCnt;
}

bool cmp(treeNode a,treeNode b) {
    return a.d[D]<b.d[D]||a.d[D]==b.d[D]&&a.d[!D]<b.d[!D];
}

void push_up(int x) {
    if (t[x].l) {
        t[x].min[0]=std:: min(t[x].min[0],t[t[x].l].min[0]);
        t[x].min[1]=std:: min(t[x].min[1],t[t[x].l].min[1]);
        t[x].max[0]=std:: max(t[x].max[0],t[t[x].l].max[0]);
        t[x].max[1]=std:: max(t[x].max[1],t[t[x].l].max[1]);
    }
    if (t[x].r) {
        t[x].min[0]=std:: min(t[x].min[0],t[t[x].r].min[0]);
        t[x].min[1]=std:: min(t[x].min[1],t[t[x].r].min[1]);
        t[x].max[0]=std:: max(t[x].max[0],t[t[x].r].max[0]);
        t[x].max[1]=std:: max(t[x].max[1],t[t[x].r].max[1]);
    }
}

void push_down(int x) {
    if (!t[x].lazy) return;
    if (t[x].l) t[t[x].l].lazy=t[t[x].l].c=t[x].lazy;
    if (t[x].r) t[t[x].r].lazy=t[t[x].r].c=t[x].lazy;
    t[x].lazy=0;
}

void modify(int now,int x1,int y1,int x2,int y2,int d,int c) {
    if (x1<=t[now].min[0]&&t[now].max[0]<=x2&&y1<=t[now].min[1]&&t[now].max[1]<=y2) {
        t[now].lazy=t[now].c=c; return ;
    }
    if (x2<t[now].min[0]||x1>t[now].max[0]||y2<t[now].min[1]||y1>t[now].max[1]) return ;
    push_down(now);
    if (x1<=t[now].d[0]&&t[now].d[0]<=x2&&y1<=t[now].d[1]&&t[now].d[1]<=y2) {
        t[now].c=c;
    }
    if (t[now].l) modify(t[now].l,x1,y1,x2,y2,!d,c);
    if (t[now].r) modify(t[now].r,x1,y1,x2,y2,!d,c);
}

int query(int now,int x,int y,int d) {
    if (t[now].lazy) return t[now].lazy;
    if (t[now].d[0]==x&&t[now].d[1]==y) return t[now].c;
    if (!d) {
        if (x<t[now].d[0]||x==t[now].d[0]&&y<t[now].d[1]) {
            return query(t[now].l,x,y,!d);
        } else return query(t[now].r,x,y,!d);
    } else {
        if (y<t[now].d[1]||y==t[now].d[1]&&x<t[now].d[0]) {
            return query(t[now].l,x,y,!d);
        } else return query(t[now].r,x,y,!d);
    }
}

int build_tree(int l,int r,int d) {
    D=d; int mid=(l+r)>>1;
    std:: nth_element(t+l,t+mid,t+r+1,cmp);
    t[mid].lazy=0; t[mid].c=1; t[mid].l=t[mid].r=0;
    if (l<mid) t[mid].l=build_tree(l,mid-1,!d);
    if (mid<r) t[mid].r=build_tree(mid+1,r,!d);
    push_up(mid);
    return mid;
}

void dfs(int x) {
    dfn[++dfn[0]]=x;
    pos[x]=dfn[0];
    size[x]=1;
    for (int i=ls[x];i;i=e[i].next) {
        dep[e[i].y]=dep[x]+1;
        dfs(e[i].y);
        size[x]+=size[e[i].y];
    }
}

int main(void) {
    freopen("data.in","r",stdin);
    freopen("myp.out","w",stdout);
    int T; scanf("%d",&T);
    while (T--) {
        fill(ls,0); edCnt=dfn[0]=0;
        t[0].max[0]=t[0].max[1]=0;
        t[0].min[0]=t[0].min[1]=MOD;
        int n,c,q; scanf("%d%d%d",&n,&c,&q);
        rep(i,2,n) {
            int fa; scanf("%d",&fa);
            add_edge(fa,i);
        }
        dep[1]=1; dfs(1);
        rep(i,1,n) {
            t[i].max[0]=t[i].min[0]=t[i].d[0]=pos[i];
            t[i].max[1]=t[i].min[1]=t[i].d[1]=dep[i];
        }
        int root=build_tree(1,n,0);
        LL ans=0;
        rep(i,1,q) {
            int x,a,b; scanf("%d%d%d",&x,&a,&b);
            if (b==0) ans=(ans+(LL)i*query(root,pos[x],dep[x],0)%MOD)%MOD;
            else modify(root,pos[x],dep[x],pos[x]+size[x]-1,dep[x]+a,0,b);
        }
        printf("%lld\n", ans);
    }
    return 0;
}