Codeforces Round #502 (in memory of Leopoldo Taravilse, Div. 1 + Div. 2) G. The Tree

G. The Tree

time limit per test

3 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Abendsen assigned a mission to Juliana. In this mission, Juliana has a rooted tree with $\mathrm{nn vertices.\; Vertex\; number 11 is\; the\; root\; of\; this\; tree.\; Each\; vertex\; can\; be\; either\; black\; or\; white.\; At\; first,\; all\; vertices\; are\; white.\; Juliana\; is\; asked\; to\; process qq queries.\; Each\; query\; is\; one\; of\; three\; types:}$

1. If vertex $\mathrm{vv is\; white,\; mark\; it\; as\; black;\; otherwise,\; perform\; this\; operation\; on\; all\; direct\; sons\; of vv instead.}$
2. Mark all vertices in the subtree of $\mathrm{vv (including vv)\; as\; white.}$
3. Find the color of the $\mathrm{ii-th\; vertex.}$

An example of operation "1 1" (corresponds to the first example test). The vertices $\mathrm{11 and 22 are\; already\; black,\; so\; the\; operation\; goes\; to\; their\; sons\; instead.}$

Can you help Juliana to process all these queries?

Input

The first line contains two integers $\mathrm{nn and qq (2\le n\le 1052\le n\le 105, 1\le q\le 1051\le q\le 105) —\; the\; number\; of\; vertices\; and\; the\; number\; of\; queries.}$

The second line contains $\mathrm{n-1n-1 integers p2,p3,\dots ,pnp2,p3,\dots ,pn (1\le pi<i1\le pi<i),\; where pipi means\; that\; there\; is\; an\; edge\; between\; vertices ii and pipi.}$

Each of the next $\mathrm{qq lines\; contains\; two\; integers titi and vivi (1\le ti\le 31\le ti\le 3, 1\le vi\le n1\le vi\le n) —\; the\; type\; of\; the ii-th\; query\; and\; the\; vertex\; of\; the ii-th\; query.}$

It is guaranteed that the given graph is a tree.

Output

For each query of type $\mathrm{33,\; print\; "black"\; if\; the\; vertex\; is\; black;\; otherwise,\; print\; "white".}$

---

 

题解：我们要使其在一个尽量平均的时间内进行求解，就需要将其改造成一个相对平衡的树，那我们就考虑用树链刨分对这颗树进行分解。我们发觉每个操作1对应使该点所在的一条重链所对应的区间黑色区间右端点后移一位，其他影响到的重链也后移一位。因此我们查询点v是否为黑色，就看从根到v点的所有链对应的区间上，任何黑色区间右端点位移位置是否超过该点v。我们对线段树维护两个值，一个是端点对应区间剩余白色点的个数leaf（可为负数，即透支后面的链的白色点数），另一个是对应区间中最靠右侧的黑色区间的右端点超出该区间右端点距离（也就是我们上文说到的对其他重链的影响长度）execr，一开始是-1因为右端点还是白色。剩余白色点的转移就是子区间白色点数相加，而第二个维护量execr（即向区间右端点后边区间的影响长度）的转移则是max(右子区间execr，左子区间execr-右子区间leaf）。这样我们查询的时候就能通过该点向后影响长度来查询该点是不是被染成黑色。>=0就是被染色了，-1则是未染色。对于操作1，直接对对应的线段树上的单点v的区间的execr++，leaf--。对于操作3，我们将根节点到节点v的所有区间连起来，算算execr是不是>-1，若是则染色了。对于操作2，我们则直接把所有对应的区间清0，即leaf为区间点数，execr为-1。为了防止v的祖先节点对v子树区间的影响，我们对v做操作3查询超出长度k，若>-1，则反向对v点做操作1（k+1）次，即execr-=（k+1），leaf+=（k+1）。

#include<bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define clr_1(x) memset(x,-1,sizeof(x))
#define INF 0x3f3f3f3f
#define LL long long
#define pb push_back
#define ls(i) (i<<1)
#define rs(i) (i<<1|1)
#define mp make_pair
#define fi first
#define se second
#define mod 1000000007
using namespace std;
const int N=2e5+100;
vector<int> e[N];
int fa[N];
struct seg
{
    int l,r,execr,leaf;
    bool tag;
}tree[N<<2];
int n,m,k,q;
int t,v;
void pushup(int i)
{
    tree[i].leaf=tree[i<<1].leaf+tree[i<<1|1].leaf;
    tree[i].execr=max(tree[i<<1|1].execr,tree[i<<1].execr-tree[i<<1|1].leaf);
    return ;
}
void init(int i,int l,int r)
{
    tree[i]=(seg){l,r,-1,1,false};
    if(l==r)
        return ;
    int mid=l+r>>1;
    init(i<<1,l,mid);
    init(i<<1|1,mid+1,r);
    pushup(i);
    return ;
}
int top[N],son[N],pre[N],las[N],stot[N],dep[N];
int tot;
void dfs1(int u,int f,int deep)
{
    stot[u]=1;
    dep[u]=deep;
    fa[u]=f;
    for(auto p:e[u])
    {
        if(p==f) continue;
        dfs1(p,u,deep+1);
        stot[u]+=stot[p];
        if(son[u]==0 || stot[son[u]]<stot[p])
            son[u]=p;
    }
    return ;
}
void dfs2(int u,int tp)
{
    pre[u]=++tot;
    top[u]=tp;
    if(son[u]) dfs2(son[u],tp);
    for(auto p:e[u])
    {
        if(p==son[u] || p==fa[u])
            continue;
        dfs2(p,p);
    }
    las[u]=tot;
    return ;
}
void pushdown(int i)
{
    if(tree[i].l!=tree[i].r)
    {
        tree[i<<1].tag=tree[i<<1|1].tag=1;
        tree[i<<1].leaf=tree[i<<1].r-tree[i<<1].l+1,tree[i<<1].execr=-1;
        tree[i<<1|1].leaf=tree[i<<1|1].r-tree[i<<1|1].l+1,tree[i<<1|1].execr=-1;
    }
    tree[i].tag=0;
    return ;
}
void update(int i,int l,int r,int val)
{
    if(tree[i].l>=l && tree[i].r<=r)
    {
        if(val==INF)//都是区间修改
            tree[i].leaf=tree[i].r-tree[i].l+1,tree[i].execr=-1,tree[i].tag=1;
        else
            tree[i].leaf-=val,tree[i].execr+=val,tree[i].tag=0;//都是单点修改
        return ;
    }
    if(tree[i].tag) pushdown(i);
    int mid=tree[i].l+tree[i].r>>1;
    if(l<=mid) update(i<<1,l,r,val);
    if(r>mid) update(i<<1|1,l,r,val);
    pushup(i);
    return ;
}
struct ret{
    int execr,leaf;
};
ret operator + (const ret &a,const ret &b)
{
    ret c;
    c.leaf=a.leaf+b.leaf;
    c.execr=max(b.execr,a.execr-b.leaf);
    return c;
}
ret query(int i,int l,int r)
{
    if(tree[i].l>=l && tree[i].r<=r)
        return (ret){tree[i].execr,tree[i].leaf};
    if(tree[i].tag) pushdown(i);
    int mid=tree[i].l+tree[i].r>>1;
    ret retur=(ret){-INF,0};
    if(r>mid) retur=query(i<<1|1,l,r)+retur;
    if(l<=mid) retur=query(i<<1,l,r)+retur;
    return retur;
}
int que(int x)
{
    int tx=top[x];
    ret retur=(ret){-INF,0},per;
    while(tx!=1)
    {
        per=query(1,pre[tx],pre[x]);
        retur=per+retur;
        x=fa[tx],tx=top[x];
    }
    per=query(1,pre[tx],pre[x]);
    retur=per+retur;
    return retur.execr;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>q;
    for(int i=2;i<=n;i++)
    {
        cin>>v;
        e[v].pb(i);
        e[i].pb(v);
    }
    init(1,1,n);
    dfs1(1,1,1);
    dfs2(1,1);
    for(int i=1;i<=q;i++)
    {
        cin>>t>>v;
        if(t==1)
            update(1,pre[v],pre[v],1);
        else if(t==2)
        {
            update(1,pre[v],las[v],INF);
            t=que(v);
            if(t>-1)
                update(1,pre[v],pre[v],-(t+1));
        }
        else if(t==3)
        {
            t=que(v);
            cout<<(t>-1?"black":"white")<<endl;
        }
    }
    return 0;
}