CoderForces343D：Water Tree（dfs序+线段树&&特殊处理）

Mad scientist Mike has constructed a rooted tree, which consists of n vertices. Each vertex is a reservoir which can be either empty or filled with water.

The vertices of the tree are numbered from 1 to n with the root at vertex 1. For each vertex, the reservoirs of its children are located below the reservoir of this vertex, and the vertex is connected with each of the children by a pipe through which water can flow downwards.

Mike wants to do the following operations with the tree:

1. Fill vertex v with water. Then v and all its children are filled with water.
2. Empty vertex v. Then v and all its ancestors are emptied.
3. Determine whether vertex v is filled with water at the moment.

Initially all vertices of the tree are empty.

Mike has already compiled a full list of operations that he wants to perform in order. Before experimenting with the tree Mike decided to run the list through a simulation. Help Mike determine what results will he get after performing all the operations.

Input

The first line of the input contains an integer n (1 ≤ n ≤ 500000) — the number of vertices in the tree. Each of the following n - 1 lines contains two space-separated numbers a_i, b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the edges of the tree.

The next line contains a number q (1 ≤ q ≤ 500000) — the number of operations to perform. Each of the following q lines contains two space-separated numbers c_i (1 ≤ c_i ≤ 3), v_i (1 ≤ v_i ≤ n), where c_i is the operation type (according to the numbering given in the statement), and v_i is the vertex on which the operation is performed.

It is guaranteed that the given graph is a tree.

Output

For each type 3 operation print 1 on a separate line if the vertex is full, and 0 if the vertex is empty. Print the answers to queries in the order in which the queries are given in the input.

Example

Input

5
1 2
5 1
2 3
4 2
12
1 1
2 3
3 1
3 2
3 3
3 4
1 2
2 4
3 1
3 3
3 4
3 5

Output

0
0
0
1
0
1
0
1

题意：给定一棵树，没棵树上有一个水池，现在有如下操作，

1，给V和其子树装水。

2，对V和其祖先排水。

3，问V是否有水。

思路1：看到操作1，操作子树，很自然地想到dfs序；然后但是2操作，V及其祖先在线段树上的位置是离散的，所以需要暴力。

转化一下思路：本来是多点更改2，单点查询3； 改为：单点更新2，区间查询3。

即：3操作改为，查询V及其子树是否都有水。

注意：对1操作，假设V的子树有空（存在无水的点）的，则需要把V的父亲改为空。     因为V的子树有空，则V的父亲为空，而且给V和子树加水后V父亲任然为空。但是由于没有单点更改V的父亲，而V的父亲和其子树都满水，则导致误判以为V的父亲有水。  而V的父亲最具有代表性，只改V的父亲节点即可。

思路2：2操作用树链剖分，避免了暴力修改，效率还过得去。

（下面的思路1的代码）

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=;
int Laxt[maxn],Next[maxn<<],To[maxn<<],cnt;
int fa[maxn],in[maxn],out[maxn],times;
void add(int u,int v)
{
    Next[++cnt]=Laxt[u];
    Laxt[u]=cnt;
    To[cnt]=v;
}
void dfs(int u,int pre)
{
    fa[u]=pre; in[u]=++times;
    for(int i=Laxt[u];i;i=Next[i]){
        int v=To[i];
        if(v!=pre) dfs(v,u);
    } out[u]=times;
}
int Lazy[maxn<<],all[maxn<<];
struct DFSTree{
    void pushdown(int Now)
    {
        if(Lazy[Now]){
            Lazy[Now]=;
            all[Now<<]=; all[Now<<|]=;
            Lazy[Now<<]=; Lazy[Now<<|]=;
        }
    }
    void pushup(int Now)
    {
        all[Now]=all[Now<<]&all[Now<<|];
    }
    void add(int Now,int L,int R,int l,int r)
    {

        if(l<=L&&r>=R) {
            Lazy[Now]=; all[Now]=; return ;
        }
        int Mid=(L+R)>>;
        pushdown(Now);
        if(l<=Mid) add(Now<<,L,Mid,l,r);
        if(r>Mid) add(Now<<|,Mid+,R,l,r);
        pushup(Now);
    }
    int query(int Now,int L,int R,int l,int r)
    {
        if(l<=L&&r>=R) return all[Now];
        int Mid=(L+R)>>;
        pushdown(Now);
        if(l<=Mid){ if(!query(Now<<,L,Mid,l,r)) return ;}
        if(r>Mid) { if(!query(Now<<|,Mid+,R,l,r)) return ;}
        pushup(Now);
        return ;
    }
    void del(int Now,int L,int R,int l,int r)
    {
        if(l<=L&&r>=R) {
            Lazy[Now]=; all[Now]=; return ;
        }
        int Mid=(L+R)>>;
        pushdown(Now);
        if(l<=Mid) del(Now<<,L,Mid,l,r);
        if(r>Mid) del(Now<<|,Mid+,R,l,r);
        /*else{
            del(Now<<1,L,Mid,l,r);
            del(Now<<1|1,Mid+1,R,l,r);
        } */
        pushup(Now);
    }
}Tree;
int main()
{
    int N,Q,u,v,i,j,opt;
    scanf("%d",&N);
    for(i=;i<N;i++){
        scanf("%d%d",&u,&v);
        add(u,v); add(v,u);
    }
    dfs(,);
    scanf("%d",&Q);
    while(Q--){
        scanf("%d%d",&opt,&u);
        if(opt==){
             if(!Tree.query(,,N,in[u],out[u]))
                Tree.del(,,N,in[fa[u]],in[fa[u]]);
             Tree.add(,,N,in[u],out[u]);
        }
        else if(opt==) Tree.del(,,N,in[u],in[u]);
        else printf("%d\n",Tree.query(,,N,in[u],out[u]));
    }
    return ;
}

加了输入优化后排第二了。

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=;
int Laxt[maxn],Next[maxn<<],To[maxn<<],cnt;
int fa[maxn],in[maxn],out[maxn],times;
void read(int &res){
    char c=getchar();
    for(;c>''||c<'';c=getchar());
    for(res=;c>=''&&c<='';c=getchar()) res=(res<<)+(res<<)+c-'';
}
void add(int u,int v)
{
    Next[++cnt]=Laxt[u];
    Laxt[u]=cnt;
    To[cnt]=v;
}
void dfs(int u,int pre)
{
    fa[u]=pre; in[u]=++times;
    for(int i=Laxt[u];i;i=Next[i]){
        int v=To[i];
        if(v!=pre) dfs(v,u);
    } out[u]=times;
}
int Lazy[maxn<<],all[maxn<<];
struct DFSTree{
    void pushdown(int Now)
    {
        if(Lazy[Now]){
            Lazy[Now]=;
            all[Now<<]=; all[Now<<|]=;
            Lazy[Now<<]=; Lazy[Now<<|]=;
        }
    }
    void pushup(int Now)
    {
        all[Now]=all[Now<<]&all[Now<<|];
    }
    void add(int Now,int L,int R,int l,int r)
    {

        if(l<=L&&r>=R) {
            Lazy[Now]=; all[Now]=; return ;
        }
        int Mid=(L+R)>>;
        pushdown(Now);
        if(l<=Mid) add(Now<<,L,Mid,l,r);
        if(r>Mid) add(Now<<|,Mid+,R,l,r);
        pushup(Now);
    }
    int query(int Now,int L,int R,int l,int r)
    {
        if(l<=L&&r>=R) return all[Now];
        int Mid=(L+R)>>;
        pushdown(Now);
        if(l<=Mid) if(!query(Now<<,L,Mid,l,r)) return ;
        if(r>Mid)  if(!query(Now<<|,Mid+,R,l,r)) return ;
        pushup(Now);
        return ;
    }
    void del(int Now,int L,int R,int l,int r)
    {
        if(l<=L&&r>=R) {
            Lazy[Now]=; all[Now]=; return ;
        }
        int Mid=(L+R)>>;
        pushdown(Now);
        if(l<=Mid) del(Now<<,L,Mid,l,r);
        if(r>Mid) del(Now<<|,Mid+,R,l,r);
        pushup(Now);
    }
}Tree;
int main()
{
    int N,Q,u,v,i,j,opt;
    read(N);
    for(i=;i<N;i++){
        read(u); read(v);
        add(u,v); add(v,u);
    }
    dfs(,);
    read(Q);
    while(Q--){
        read(opt); read(u);
        if(opt==){
             if(!Tree.query(,,N,in[u],out[u]))
                Tree.del(,,N,in[fa[u]],in[fa[u]]);
             Tree.add(,,N,in[u],out[u]);
        }
        else if(opt==) Tree.del(,,N,in[u],in[u]);
        else printf("%d\n",Tree.query(,,N,in[u],out[u]));
    }
    return ;
}