[BZOJ3637]-QTREE6-LCT

说在前面

码一码LCT
再不码都要遗忘掉了…

---

题目

BZOJ3637传送门

题目大意

给出一棵有 $n$ 个点的树，树的节点有颜色，初始全部是黑色
现在需要支持以下两种操作，总操作数为 $m$：

• $0~u$ ：询问 $u$ 所在的同色联通块的大小
• $1~u$ ：将 $u$ 点反转颜色

范围：$n,m\leq 10^5$

输入输出格式

输入格式：
第一行一个整数 $n$，表示点数
接下来 $n-1$ 行，每行两个整数描述一条树边
接下来一个整数 $m$，描述操作数
接下来 $m$ 行，每行描述一个操作，格式如题

输出格式：
对于每个询问操作，输出一行一个整数表示答案

---

解法

这道题用 树剖/LCT 都可以做来着
LCT的做法还是比较简单的（其实不如说是套路emmmm

我们不能直接维护黑色点的联通块以及白色点的联通块，因为这样的复杂度与点的度数相关

所以我们这样搞，把所有黑点连上它的父节点组成一颗 黑森林，白点也类似
这样的话，修改一个点的颜色所带来的影响，只有一个点
并且这样查询也不麻烦。可以发现，对于森林里的一棵树，只有它的根的颜色是不确定的，所以我们在询问的时候，只需要判断 根与当前询问点 是否同色，同色则取根的答案，否则取该联通块 最接近根的那个点 的答案（找前驱然后Access即可）

---

下面是自带大长度的代码

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

int N , M , head[100005] , tp , fa[100005] , col[100005] ;
struct Path{
    int pre , to ;
} p[200005] ;

struct Node{
    Node *ch[2] , *fa ;
    int rsiz , isiz ;
    void update(){
        rsiz = 1 ;
        if( ch[0] ) rsiz += ch[0]->rsiz + ch[0]->isiz ;
        if( ch[1] ) rsiz += ch[1]->rsiz + ch[1]->isiz ;
    }
} *sta[100005] ;

struct LCT{
    Node w[100005] ;
    void init(){
        for( int i = 1 ; i <= N ; i ++ ){
            w[i].ch[0] = w[i].ch[1] = w[i].fa = NULL ;
            w[i].rsiz = 1 , w[i].isiz = 0 ;
        }
    }
    bool isRoot( Node *nd ){
        if( !nd->fa ) return true ;
        return nd->fa->ch[0] != nd && nd->fa->ch[1] != nd ;
    }
    void Rotate( Node *nd , int k ){
        Node *x = nd->ch[k] ;
        if( nd->fa ){
            if( nd->fa->ch[0] == nd ) nd->fa->ch[0] = x ;
            if( nd->fa->ch[1] == nd ) nd->fa->ch[1] = x ;
        } x->fa = nd->fa ;
        if( x->ch[k^1] ) x->ch[k^1]->fa = nd ;
        nd->ch[k] = x->ch[k^1] ;
        nd->fa = x , x->ch[k^1] = nd ;
        nd->update() , x->update() ;
    }
    void Splay( Node *nd ){
        /*  int tp = 0 ; Node *tmp = nd ;
            while( !isRoot( tmp ) ) sta[++tp] = tmp , tmp = tmp->fa ;
            sta[++tp] = tmp ; while( tp ) sta[tp]->pushdown() , tp -- ;
        */
        while( !isRoot( nd ) ){
            Node *fa = nd->fa , *gdfa = fa->fa ;
            int pn = ( fa->ch[1] == nd ) , pf ;
            if( !isRoot( fa ) ){
                pf = ( gdfa->ch[1] == fa ) ;
                if( pn == pf ) swap( fa , gdfa ) ;
                Rotate( fa , pn ) , Rotate( gdfa , pf ) ;
            } else Rotate( fa , pn ) ;
        }
    }
    void Access( Node *nd ){
        Node *tmp = NULL ;
        while( nd ){
            Splay( nd ) ;
            if( nd->ch[1] ) nd->isiz += nd->ch[1]->rsiz + nd->ch[1]->isiz ;
            if( tmp ) nd->isiz -= tmp->rsiz + tmp->isiz ;
            nd->ch[1] = tmp ; nd->update() ;
            tmp = nd , nd = nd->fa ;
        }
    }
    void link( int x , int y ){ // link u to v
        if( !y ) return ;
        Node *u = ( w + x ) , *v = ( w + y ) ;
        Access( v ) , Splay( v ) ;
        Splay( u ) , u->fa = v , v->isiz += u->rsiz + u->isiz ;
    }
    void cut( int x , int y ){ // x is a child of y
        if( !y ) return ;
        Node *u = ( w + x ) , *v = ( w + y ) ;
        Access( v ) , Splay( v ) ; Splay( u ) ;
        v->isiz -= u->rsiz + u->isiz ;
        u->fa = NULL ;
    }
    Node *getMin( Node *nd ){
        while( nd->ch[0] ) nd = nd->ch[0] ;
        return nd ;
    }
    int Query( int x ){
        Node *u = ( w + x ) , *tmp , *t2 ;
        Access( u ) , Splay( u ) ;
        tmp = getMin( u ) , Splay( tmp ) ;
        if( col[ tmp - w ] != col[x] ){
            Access( t2 = getMin( tmp->ch[1] ) ) , Splay( tmp ) ;
            return t2->rsiz + t2->isiz ;
        } return tmp->rsiz + tmp->isiz ;
    }
} Tree[2] ;

void In( int t1 , int t2 ){
    p[++tp] = ( Path ){ head[t1] , t2 } ; head[t1] = tp ;
    p[++tp] = ( Path ){ head[t2] , t1 } ; head[t2] = tp ;
}

void dfs( int u , int f ){
    for( int i = head[u] ; i ; i = p[i].pre ){
        int v = p[i].to ;
        if( v == f ) continue ;
        Tree[1].link( v , u ) ;
        fa[v] = u , dfs( v , u ) ;
    } col[u] = 1 ;
}

void solve(){
    scanf( "%d" , &M ) ;
    for( int i = 1 , opt , u ; i <= M ; i ++ ){
        scanf( "%d%d" , &opt , &u ) ;
        if( opt == 0 ) printf( "%d\n" , Tree[ col[u] ].Query( u ) ) ;
        else {
            Tree[ col[u] ].cut( u , fa[u] ) ;
            col[u] ^= 1 , Tree[ col[u] ].link( u , fa[u] ) ;
        }
    }
}

int main(){
    scanf( "%d" , &N ) ;
    Tree[0].init() , Tree[1].init() ;
    for( int i = 1 , u , v ; i < N ; i ++ )
        scanf( "%d%d" , &u , &v ) , In( u , v ) ;
    dfs( 1 , 1 ) ; solve() ;
}