[CodeChef-QTREE6]Query on a tree VI

题目大意：
　　给你一棵黑白树，每个点默认是白色，要求支持以下两种操作：
　　　　1.改变一个点的颜色；
　　　　2.除去连接不同颜色的点的边，求某个点连通块的大小。

思路：
　　对原树维护两个树链剖分，
　　一棵维护当点x为白色时，以它为根结点的白色的子树大小；
　　另一棵维护当点x为黑色时，以它为根结点的黑色的子树大小。（两者均不考虑x的实际颜色）
　　方便起见，这里我们用q表示同一个连通分量中，深度最浅的祖先。
　　询问一个点时，相当于在询问q的值。
　　修改一个点时，相当于在原来颜色的树剖上将x到q的路径上的所有点同时减去x同色子树的大小，然后在新的颜色的树剖上将x到q路径上的所有点同时加上x同色子树的大小。
　　如果对每个点都加/减显然不方便，因此我们可以用一些数据结构（线段树/树状数组）来维护差分。
　　注意这道题会卡常，要么对每一条链建线段树，要么就用树状数组。
　　接下来的问题是如何找到祖先q。
　　如果暴力往上找，时间复杂度是O(n)的，显然会TLE。
　　假如我们能够直接判断某一个树链上的点是否是同一种颜色，那就可以直接往上跳了。
　　如何直接判断？
　　考虑用0代表白色，1代表黑色，如果当这条链上所有点的权值和等于这条链上结点的个数，或等于0，那么肯定是同一种颜色的。
　　这样我们可以直接维护树上前缀和，询问的时候减一下就可以了。
　　最后还剩半条链没法跳的时候可以二分中间的结点。

 #include<cstdio>
 #include<cctype>
 #include<vector>
 inline int getint() {
     char ch;
     while(!isdigit(ch=getchar()));
     int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 const int V=;
 std::vector<int> e[V];
 inline void add_edge(const int &u,const int &v) {
     e[u].push_back(v);
 }
 int par[V],size[V],son[V],top[V],id[V],dep[V],id2[V],n;
 bool col[V];
 void dfs1(const int &x,const int &p) {
     par[x]=p;
     size[x]=;
     dep[x]=dep[p]+;
     for(unsigned i=;i<e[x].size();i++) {
         const int &y=e[x][i];
         if(y==p) continue;
         dfs1(y,x);
         size[x]+=size[y];
         if(size[y]>size[son[x]]) {
             son[x]=y;
         }
     }
 }
 void dfs2(const int &x) {
     id[x]=++n;
     id2[n]=x;
     top[x]=x==son[par[x]]?top[par[x]]:x;
     if(son[x]) dfs2(son[x]);
     for(unsigned i=;i<e[x].size();i++) {
         const int &y=e[x][i];
         if(y==par[x]||y==son[x]) continue;
         dfs2(y);
     }
 }
 class FenwickTree {
     private:
         int val[V];
         int lowbit(const int &x) {
             return x&-x;
         }
     public:
         void modify(int p,const int &x) {
             while(p<=n) {
                 val[p]+=x;
                 p+=lowbit(p);
             }
         }
         int query(int p) {
             int ret=;
             while(p) {
                 ret+=val[p];
                 p-=lowbit(p);
             }
             return ret;
         }
 };
 FenwickTree t[];
 bool check(const int &u,const int &m) {
     return t[].query(id[u])-t[].query(id[m]-)==col[u]*(dep[u]-dep[m]+);
 }
 inline int get_anc(int u) {
     while(top[u]!=&&check(u,top[u])) {
         if(col[par[top[u]]]==col[u]) {
             u=par[top[u]];
         } else {
             return top[u];
         }
     }
     int l=id[top[u]],r=id[u];
     while(l<=r) {
         const int mid=(l+r)>>;
         if(check(u,id2[mid])) {
             r=mid-;
         } else {
             l=mid+;
         }
     }
     return id2[r+];
 }
 inline void modify2(int x,int y,const int &k,const bool &c) {
     while(top[x]!=top[y]) {
         t[c].modify(id[top[x]],k);
         t[c].modify(id[x]+,-k);
         x=par[top[x]];
     }
     t[c].modify(id[y],k);
     t[c].modify(id[x]+,-k);
 }
 inline void modify(const int &u) {
     if(u!=) modify2(par[u],par[get_anc(u)],-t[col[u]].query(id[u]),col[u]);
     t[].modify(id[u],col[u]?-:);
     col[u]^=true;
     if(u!=) modify2(par[u],par[get_anc(u)],t[col[u]].query(id[u]),col[u]);
 }
 inline int query(const int &u) {
     return t[col[u]].query(id[get_anc(u)]);
 }
 int main() {
     int n=getint();
     for(register int i=;i<n;i++) {
         const int u=getint(),v=getint();
         add_edge(u,v);
         add_edge(v,u);
     }
     dfs1(,);
     dfs2();
     for(register int i=;i<=n;i++) {
         t[].modify(id[i],size[i]);
         t[].modify(id[i]+,-size[i]);
     }
     t[].modify(,);
     for(register int m=getint();m;m--) {
         const int t=getint(),u=getint();
         if(t) {
             modify(u);
         } else {
             printf("%d\n",query(u));
         }
     }
     return ;
 }