[LOJ][SDOI2017]树点涂色

链接

（蒟蒻只能够想到 3 操作可以用树剖线段树维护ORZ）
对于每个 1 操作 ， 都会覆盖当前节点到根节点的所有颜色 ， 且新颜色对所有经过操作节点的路径都有贡献。
所以我们维护所有边的两边颜色是否相同 ， 易知在不相同情况下这条边有1的贡献 , 在这种情况下我们就能够对 2 操作进行维护了（考虑差分）

在这里我们用 $ D_{i} $ 表示点 i 到根存在多少这样的边 ，则操作 2 的 答案为 $ Ans = D_{x} + D_{y} - 2 * D_{lca(x , y)} + 1 $

接下来考虑如何维护这些边。

我们会发现覆盖当前节点到根节点的操作与 LCT 中的 Access 操作类似 ，

所以在这里我们就可以用轻重边来表示这些不同的边了！

用 Access 来模拟操作 1 过程 , 重边 - > 轻边 则进行子树加 ， 轻边 - > 重边 则进行子树减

由于我们只要维护 LCT 中的 Access , 所以只要对Access操作进行一些修改就行了

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>

using namespace std;

const int N = 1e5 + 5;

struct Virt{
    double x , y;
    Virt(double _x = 0.0 , double _y = 0.0):x(_x) , y(_y){}
};

Virt operator + (Virt x , Virt y){return Virt(x.x + y.x , x.y + y.y);}
Virt operator - (Virt x , Virt y){return Virt(x.x - y.x , x.y - y.y);}
Virt operator * (Virt x , Virt y){return Virt(x.x * y.x - x.y * y.y , x.x * y.y + x.y * y.x);}

int read(){
	int x = 0 , f = 1; char ch = getchar();
	while(ch < '0' || ch > '9'){if(ch == '-') f = -1 ; ch = getchar();}
	while(ch >= '0' && ch <= '9'){x = x * 10 + ch - '0'; ch = getchar();}
	return x * f;
}

int n , Q , opt , x , y;
int num , posin[N] , posout[N] , tot , head[N];
int fa[N] , dep[N] , sz[N] , top[N] , son[N] , tree[N];

struct edge{
	int pos , nx;
}e[N << 1];

void add(int u , int v){
	e[++num].pos = v; e[num].nx = head[u]; head[u] = num;
	e[++num].pos = u; e[num].nx = head[v]; head[v] = num;
}


void dfs1(int now){
	sz[now] = 1;
	for(int i = head[now] ; i ; i = e[i].nx){
		if(e[i].pos == fa[now]) continue;
		fa[e[i].pos] = now; dep[e[i].pos] = dep[now] + 1;
		dfs1(e[i].pos);
		sz[now] += sz[e[i].pos];
		if(sz[e[i].pos] > sz[son[now]]) son[now] = e[i].pos;
	}
}

void dfs2(int now , int father){
	posin[now] = ++tot; tree[tot] = now;
	top[now] = father;
	if(son[now]) dfs2(son[now] , father);
	for(int i = head[now] ; i ; i = e[i].nx){
		if(e[i].pos == son[now] || e[i].pos == fa[now]) continue;
		dfs2(e[i].pos , e[i].pos);
	}
	posout[now] = tot;
}

int lca(int x , int y){
	while(top[x] != top[y]){
		if(dep[top[x]] < dep[top[y]]) swap(x,y);
		x = fa[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

struct SegmentTree{
	struct node{
		int tag , val;
	}tr[N << 2];

	void paint(int k , int d){
		tr[k].tag += d; tr[k].val+=d;
	}

	void push_down(int k){
		paint(k << 1 , tr[k].tag);
		paint(k << 1 | 1 , tr[k].tag);
		tr[k].tag = 0;
	}

	void merge(int k){tr[k].val = max(tr[k << 1].val , tr[k << 1 | 1].val);}

	void build(int k , int l , int r){
		if(l == r) tr[k].val = dep[tree[l]] + 1;
		else build(k << 1 , l , (l + r) >> 1) , build(k << 1 | 1 , ((l + r) >> 1) + 1 , r) , merge(k);
	}

	int query1(int k , int l , int r , int pos){
		if(l == r) return tr[k].val;
		else{
			if(tr[k].tag) push_down(k);
			int mid = (l + r) >> 1;
			if(mid >= pos) return query1(k << 1 , l , mid , pos);
			else return query1(k << 1 | 1, mid + 1 , r , pos);
		}
	}

	int query2(int k , int l , int r , int L , int R){
		if(L <= l && r <= R) return tr[k].val;
		else{
			if(tr[k].tag) push_down(k);
			int mid = (l + r) >> 1 , ans = 0;
			if(mid >= L) ans = max(ans , query2(k << 1 , l , mid , L , R));
			if(mid < R) ans = max(ans , query2(k << 1 | 1 , mid + 1 , r , L , R));
			return ans;
		}
	}

	void change(int k , int  l , int r , int L , int R , int d){
		if(l >= L && r <= R) paint(k , d);
		else{
			if(tr[k].tag) push_down(k);
			int mid = (l + r) >> 1;
			if(mid >= L) change(k << 1 , l , mid , L , R , d);
			if(mid < R) change(k << 1 | 1 , mid + 1 , r , L , R , d);
			merge(k);
		}
	}

}seg;

void addsub(int k , int d){seg.change(1 , 1 , n , posin[k] , posout[k] , d);}
int subquery(int x , int y){
	int temp = lca(x , y);
	//printf("lca : %d\n",temp);
	int ans = seg.query1(1 , 1 , n , posin[x]) + seg.query1(1 , 1 , n , posin[y]) - 2 * seg.query1(1 , 1 , n , posin[temp]) + 1;
	return ans;
}

int maxquery(int k){
	int ans = seg.query2(1 , 1 , n , posin[k] , posout[k]);
	return ans;
}

struct Link_Cut_Tree{
	struct node{int ch[2] , fa;}tr[N];

	int get_son(int x){return tr[tr[x].fa].ch[1] == x;}
	bool is_root(int x){return tr[tr[x].fa].ch[0] != x && tr[tr[x].fa].ch[1] != x;}

	void rotate(int k){
		int f = tr[k].fa , ffa = tr[f].fa , c = get_son(k);
		if(!is_root(f)) tr[ffa].ch[tr[ffa].ch[1] == f] = k; tr[k].fa = ffa;
		tr[f].ch[c] = tr[k].ch[!c]; tr[tr[f].ch[c]].fa = f;
		tr[k].ch[!c] = f; tr[f].fa = k;
	}	

	void splay(int x){
		for(int f ; !is_root(x) ; rotate(x))
			if(!is_root(f = tr[x].fa))
				rotate(get_son(x) == get_son(f) ? f : x);
	}

	int find_root(int x){
		splay(x);
		while(tr[x].ch[0]) x = tr[x].ch[0];
		splay(x);
		return x;
	}	

	void access(int x){
		for(int y = 0 ; x ; y = x , x = tr[x].fa){
			splay(x);
			if(tr[x].ch[1]){
				int temp = tr[x].ch[1]; tr[x].ch[1] = 0;
				temp = find_root(temp); addsub(temp , 1);
			}
			if(y) y = find_root(y) , addsub(y , -1);
			
			tr[x].ch[1] = y;
		}
	}

	void init(){for(int i = 1 ; i <= n ; i++) tr[i].fa = fa[i];};
}lct;

int main(){
	scanf("%d%d",&n,&Q);
	for(int i = 1 ; i < n ; i++) scanf("%d%d",&x,&y) , add(x , y);
	dfs1(1); dfs2(1 , 1); seg.build(1 , 1 , n); lct.init();
	for(int i = 1 ; i <= Q ; i++){
		scanf("%d%d",&opt,&x);
		if(opt == 1) lct.access(x);
		else if(opt == 2) scanf("%d",&y) , printf("%d\n" , subquery(x , y));
		else printf("%d\n" , maxquery(x)); 
	}
	return 0; 
}