SPOJ QTREE6

题意

给你一棵\(n\)个点的树，编号\(1\)~\(n\)。每个点可以是黑色，可以是白色。初始时所有点都是黑色。有两种操作

\(0\ u\)：询问有多少个节点\(v\)满足路径\(u\)到\(v\)上所有节点（包括）都拥有相同的颜色

\(1\ u\)：翻转\(u\)的颜色

Sol

\(LCT\)做法：

黑白开两个\(LCT\)

然后有一个很\(Naive\)的做法

就是每次改颜色时，暴力枚举连的点，\(Link\)或\(Cut\)

显然菊花树直接就卡掉了

优化

把树定成一棵以\(1\)为根的有根树，然后把颜色放在它的父亲与它相连的边上

然后维护子树信息

\(Link\)或\(Cut\)就只涉及一条边

注意到每个子树的根不一定同色

询问时要特判根的颜色

就是\(Access\)一下，然后\(Splay\)，跳左儿子找到根，并把它\(Splay\)

如果同色，就输出它的子树信息，否则输出它的右儿子的子树信息

应为右儿子深度比它大，所以，右儿子的子树信息就是答案

由于我们定义它是有根树

那么我们不能\(Makeroot\)，这样的话才能保证能找到当前子树的根

那么\(Link\)时，为保证它父亲以上的点不受影响，\(Access\)并\(Splay\)它父亲

又因为它就是当前的子树的根，把它\(Splay\)一下，之后再连虚边

\(Cut\)时，把它\(Access\)并\(Splay\)，那么它的父亲就在左子树，直接删掉它和它左儿子的实边是没有影响的

# include <bits/stdc++.h>
# define RG register
# define IL inline
# define Fill(a, b) memset(a, b, sizeof(a))
using namespace std;
typedef long long ll;
const int _(1e5 + 5);

IL int Input(){
	RG int x = 0, z = 1; RG char c = getchar();
	for(; c < '0' || c > '9'; c = getchar()) z = c == '-' ? -1 : 1;
	for(; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
	return x * z;
}

struct LCT{
	typedef int Arr[_];
	Arr fa, ch[2], sum, val;

	IL int Son(RG int x){
		return ch[1][fa[x]] == x;
	}

	IL int Isroot(RG int x){
		return ch[0][fa[x]] != x && ch[1][fa[x]] != x;
	}

	IL void Update(RG int x){
		sum[x] = sum[ch[0][x]] + sum[ch[1][x]] + val[x] + 1;
	}

	IL void Rotate(RG int x){
		RG int y = fa[x], z = fa[y], c = Son(x);
		if(!Isroot(y)) ch[Son(y)][z] = x; fa[x] = z;
		ch[c][y] = ch[!c][x], fa[ch[c][y]] = y;
		ch[!c][x] = y, fa[y] = x, Update(y);
	}

	IL void Splay(RG int x){
		for(RG int y = fa[x]; !Isroot(x); Rotate(x), y = fa[x])
			if(!Isroot(y)) Son(x) ^ Son(y) ? Rotate(x) : Rotate(y);
		Update(x);
	}

	IL void Access(RG int x){
		for(RG int y = 0; x; y = x, x = fa[x]){
			Splay(x), val[x] += sum[ch[1][x]] - sum[y];
			ch[1][x] = y, Update(x);
		}
	}

	IL int Findroot(RG int x){
		Access(x), Splay(x);
		while(ch[0][x]) x = ch[0][x];
		Splay(x);
		return x;
	}

	IL void Link(RG int x, RG int y){
		if(!y) return;
		Access(y), Splay(x), Splay(y);
		fa[x] = y, val[y] += sum[x], Update(y);
	}

	IL void Cut(RG int x, RG int y){
		if(!y) return;
		Access(x), Splay(x);
		ch[0][x] = fa[ch[0][x]] = 0, Update(x);
	}
} T[2];
int fa[_], n, m, col[_];
vector <int> G[_];

IL void Dfs(RG int u, RG int ff){
	for(RG int i = 0, l = G[u].size(); i < l; ++i){
		RG int v = G[u][i];
		if(v == ff) continue;
		T[1].Link(v, u), fa[v] = u;
		Dfs(v, u);
	}
}

int main(RG int argc, RG char *argv[]){
	n = Input();
	for(RG int i = 1; i <= n; ++i) col[i] = 1;
	for(RG int i = 1; i < n; ++i){
		RG int u = Input(), v = Input();
		G[u].push_back(v), G[v].push_back(u);
	}
	Dfs(1, 0), m = Input();
	for(RG int i = 1; i <= m; ++i){
		RG int op = Input(), x = Input(), ff, &c = col[x];
		if(op) T[c].Cut(x, fa[x]), c ^= 1, T[c].Link(x, fa[x]);
		else{
			T[c].Access(x), ff = T[c].Findroot(x);
			if(col[ff] == c) printf("%d\n", T[c].sum[ff]);
			else printf("%d\n", T[c].sum[T[c].ch[1][ff]]);
		}
	}
	return 0;
}