Codeforces 1017G The Tree

題目大意：

給一個一開始所有節點都是白色的樹，給一些查詢操作，給的三種操作：
1.在v的所有子節點中向下深搜，直到找到第一個白色子孫節點（或者自己），染成黑色。
2.把v的所有子樹（包括它自己）全部染白。
3.輸出v節點的顏色。

思路：

一般想到就是大模擬，直接暴力深搜Q次，操作3是O(1),其他都是O(n),時間複雜度總的就是。。。。O(nq$nq$),Boom~
所以看了看官方題解，畢竟這個是相當於Div1 E題難度的題目，我這種接近Newbie警告的pupil，怎麼可能會寫。。。但是看過官方題解覺得好像不難啊，就決定花一個早上研究了一下寫掉了，而且發現標程裡面有些東西是不太必要的，比如那個存放原本狀態的old_black陣列。初始化我改用了memset，比for迴圈稍好，並且不像標程一樣每一個V2陣列都要重新初始化，我只初始化本輪查詢需要用到的就可以了。然而。。。並沒有什麼卵用，總的思路和標程是一樣一樣的。
總的思路是對查詢分塊建立一棵小樹，只存放被查詢到的點，並記錄被查詢到的節點間白色塊的數量，在小樹上DFS進行三種操作，直到該塊查詢全部預處理完成後再將更新應用到整棵樹上。總的時間複雜度一下子就降到了O(

#include <iostream>
#include <vector>
#include <cmath>
#include <cstring>
using namespace std;
struct mini//the data structure storing edges of the mini-tree
 

{
    int to;//the son vertex
    int white;//the number of white vertices between two vertices we need to operate in the mini-tree
    int dis;//the distance between two mini-tree vertices in the original tree, we need this to do the operation 2
};
int v[100005];//the vertex we need to operate
int t[100005];//the type of operation we do
 

vector<int> edge[100005];//the origin tree, which has no weight on its edges. So we just need to storage its end.
vector<mini> minitree[100005];// A mini Tree, with a weighted edge
bool vis[100005];//mark the vertex if we need to add the vertex to the mini-tree
bool cl[100005];//mark if the clear operation should be done
bool isblack[100005];//mark the vertex. isblack[i] is true when i-th vertex is black
int pusher[100005];//check how many operation 1s should be done to the son 
void builder(int now,int pre,int white,int dis)
{
    //cout<<now<<endl;
    if(vis[now])
    {
        if(pre!=0)
        {
            mini temp;
            temp.to=now;
            temp.white=white;
            temp.dis=dis;
            minitree[pre].push_back(temp);//add an edge to the mini-tree
        }
        for(int i=0; i<edge[now].size(); i++)
        {
            builder(edge[now][i],now,0,0);//clear the number of whites and the distance
        }
    }
    else
    {
        if(!isblack[now])
        {
            white++;//count the white vertices
        }
        for(int i=0; i<edge[now].size(); i++)
        {
            builder(edge[now][i],pre,white,dis+1);//bypass all other vertices but count the white ones between two key vertices
        }
    }
}
void op1(int now)
{
    if(!isblack[now])
    {
        isblack[now]=true;//if the vertex is still white, just paint it black and quit
        return;
    }
    else
    {
        pusher[now]++;//remember the blocks to be drawn but not now,save some time if clear op is found;
        for(int i=0; i<minitree[now].size(); i++)
        {
            if(pusher[now]>minitree[now][i].white)
            {
                minitree[now][i].white=0;//this doesn't matter, the white value won't be used any more this round (because both of the vertices are marked black,you may never go to line 62,where is the only line which need this value again.),but we know, in this situation, it's natural to think that no vertices between the father and the son are white
                op1(minitree[now][i].to);//if the operation 1 was done more than the white vertices between two key vertices, just do it for his son
            }
        }
    }
}

void op2(int now)
{
    isblack[now]=false;
    pusher[now]=0;//all the sons are marked white, so all the pushes we made were abandoned
    cl[now]=true;
    for(int i=0; i<minitree[now].size(); i++)
    {
        minitree[now][i].white=minitree[now][i].dis;//if the vertex should be marked black again ,you may found this is affecting line 62.
        op2(minitree[now][i].to);
    }
}
void push_down(int now,bool clr,int push)
{
    if(vis[now])
    {
        clr=cl[now];
        push=pusher[now];
    }
    else//the vertices in minitree has correct status already if there's no else, you will find if the direct father of the visited vertex who have done the operation 2 already  has a push number of 1, the vertex will be wrongly marked white
    {
        if(clr)//if the vertex was cleared before, we need to clear it first, because operation2's area is much bigger than the operation 1,and the vertex may be marked black again.
        {
            isblack[now]=false;
        }
        if(!isblack[now] && push>0)
        {
            isblack[now]=true;
            push--;
        }
    }
    for(int i=0; i<edge[now].size(); i++)
    {
        push_down(edge[now][i],clr,push);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n,q;
    cin>>n>>q;
    for(int i=2; i<=n; i++)
    {
        int temp;
        cin>>temp;
        edge[temp].push_back(i);
    }
    for(int i=1; i<=q; i++)
    {
        cin>>t[i]>>v[i];
    }
    memset(isblack,0,sizeof(isblack));//all the vertices were white before we do the operations
    int block=sqrt(n);
    for(int i=1; i<=q; i+=block)//Block the queries into pieces, one loop O(n+sqrt(n)+sqrt(n)+n),totally O(2(n+n*sqrt(n)))
    {

        memset(vis,0,sizeof(vis));//memset() is a little bit faster than the O(n) for loop, but still O(n)
        memset(cl,0,sizeof(cl));
        memset(pusher,0,sizeof(pusher));
        for(int j=0; j<block && i+j<=q; j++)//O(block),or O(sqrt(n))
        {
            minitree[v[i+j]].clear();//we just need to initialize the vectors we will use this time
            vis[v[i+j]]=true;

        }
        builder(1,0,0,0);//Build the mini tree with the original tree so that you can save a lot of time by bypassing useless vertices.This method is based on DFS, Traversal every vertex once, O(n)
        for(int j=0; j<block && i+j<=q; j++)
        {
            switch(t[i+j])
            {
            case 1:
                op1(v[i+j]);//DFS once in mini-tree, no more than O(block) or O(sqrt(n))
                break;
            case 2:
                op2(v[i+j]);//also DFS in mini-tree, O(block) or O(sqrt(n))
                break;
            case 3:
                if(isblack[v[i+j]])
                {
                    cout<<"black\n";
                }
                else
                {
                    cout<<"white\n";
                }
            }
        }
        push_down(1,0,0);// renew the tree,DFS in original tree,O(n)
    }

    return 0;
}