\(\color{#0066ff}{ 题目描述 }\)

Bob有一棵\(n\)个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。

定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。

Bob可能会进行这几种操作：

• 1 x

把点\(x\)到根节点的路径上所有的点染上一种没有用过的新颜色。

• 2 x y

求\(x\)到\(y\)的路径的权值。

• 3 x

在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。

Bob一共会进行\(m\)次操作

\(\color{#0066ff}{输入格式}\)

第一行两个数\(n,m\)。

接下来\(n-1\)行，每行两个数\(a,b\)，表示\(a\)与\(b\)之间有一条边。

接下来\(m\)行，表示操作，格式见题目描述

\(\color{#0066ff}{输出格式}\)

每当出现2,3操作，输出一行。

如果是2操作，输出一个数表示路径的权值

如果是3操作，输出一个数表示权值的最大值

\(\color{#0066ff}{输入样例}\)

5 6

1 2

2 3

3 4

3 5

2 4 5

3 3

1 4

2 4 5

1 5

2 4 5

\(\color{#0066ff}{输出样例}\)

3

4

2

2

\(\color{#0066ff}{数据范围与提示}\)

共10个测试点

测试点1，\(1\leq n,m\leq1000\)

测试点2、3，没有2操作

测试点4、5，没有3操作

测试点6，树的生成方式是，对于i(\(2\leq i \leq n\))i(2≤i≤n)，在1到\(i-1\)中随机选一个点作为i的父节点。

测试点7，\(1\leq n,m\leq 50000\)

测试点8，\(1\leq n \leq 50000\)

测试点9,10，无特殊限制

对所有数据，\(1\leq n \leq 10^5\)，\(1\leq m \leq 10^5\)

时间限制：1s

空间限制：128MB

\(\color{#0066ff}{ 题解 }\)

震惊！这题能用LCT，蒟蒻刚拿到这题一脸懵逼。。。

怎么用LCT维护颜色呢。。。显然不能每种颜色都一个LCT吧。。（MLE。。）

诶，不能每种颜色一个LCT，每种颜色一个Splay呢，这是可以的吧。。。

正好发现一个东西，每时每刻颜色相同的点一定是一条深度严格递增的链！

于是。。。真的就每个颜色一个Splay了

现在开始考虑操作

第一个操作，显然access就行了。。。

第二个操作， 我们肯定是不能琛出x到y的链的，这样就乱了

那么LCT就维护不了这个东西了。但是没有LCT还要支持两个点的询问。。。

复杂度保证的情况下只有树上差分了吧（\(ans[x]+ans[y]-ans[lca]\)）

我们记\(f[x]\)为x到根的答案，那么x到y的答案就是\(f[x]+f[y]-2*f[lca]+1\)

加1是因为LCA被减两次

这个LCA显然只能倍增了。。LCT是动不了的

然后你这\(f\)咋求啊？

初始的时候肯定是深度没错， 实际上它就是x到根的虚边的个数+1

因此在access的时候就能修改

可是，虚实变换的时候，影响的是一棵子树啊， 这是子树修改

于是。。。线段树维护个dfs序就可以完美的解决

然后第三个操作，就是线段树上区间max，就没了。。。

#include<bits/stdc++.h>

#define LL long long

LL in() {

	char ch; LL x = 0, f = 1;

	while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);

	for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));

	return x * f;

}

const int maxn = 1e5 + 10;

struct node {

	node *ch[2], *fa;

	node() { ch[0] = ch[1] = fa = NULL; }

	bool isr() { return this == fa->ch[1]; }

	bool ntr() { return fa && (fa->ch[0] == this || fa->ch[1] == this); }

}pool[maxn];

struct Tree {

	Tree *ch[2];

	int l, r, max, tag;

	Tree(int l = 0, int r = 0, int max = 0, int tag = 0): l(l), r(r), max(max), tag(tag) {}

	void trn(int val) { max += val, tag += val; }

	void upd() { max = std::max(ch[0]->max, ch[1]->max); }

	void dwn() {

		if(!tag) return;

		ch[0]->trn(tag);

		ch[1]->trn(tag);

		tag = 0;

	}

}Tpool[maxn << 2], *Ttail = Tpool, *root;

struct EDGE {

	int to;

	EDGE *nxt;

	EDGE(int to = 0, EDGE *nxt = NULL): to(to), nxt(nxt) {}

}Epool[maxn << 2], *Etail = Epool;

EDGE *head[maxn];

int f[maxn][26], dfn[maxn], dep[maxn], cnt, n, m, redfn[maxn], siz[maxn];

void rot(node *x) {

	node *y = x->fa, *z = y->fa;

	bool k = x->isr(); node *w = x->ch[!k];

	if(y->ntr()) z->ch[y->isr()] = x;

	(x->ch[!k] = y)->ch[k] = w;

	(y->fa = x)->fa = z;

	if(w) w->fa = y;

}

void splay(node *o) {

	while(o->ntr()) {

		if(o->fa->ntr()) rot(o->isr() ^ o->fa->isr()? o : o->fa);

		rot(o);

	}

}

void add(int from, int to) {

	head[from] = new(Etail++) EDGE(to, head[from]);

}

void dfs(int x, int fa) {

	dep[redfn[dfn[x] = ++cnt] = x] = dep[(pool[x].fa = pool + (f[x][0] = fa)) - pool] + (siz[x] = 1);

	for(EDGE *i = head[x]; i; i = i->nxt) {

		if(i->to == fa) continue;

		dfs(i->to, x);

		siz[x] += siz[i->to];

	}

}

void build(Tree *&o, int l, int r) {

	o = new(Ttail++) Tree(l, r, 0, 0);

	if(l == r) return(void)(o->max = dep[redfn[l]]);

	int mid = (l + r) >> 1;

	build(o->ch[0], l, mid), build(o->ch[1], mid + 1, r);

	o->upd();

}

void lazy(Tree *o, int l, int r, int k) {

	if(l <= o->l && o->r <= r) return (void)(o->trn(k));

	o->dwn();

	int mid = (o->l + o->r) >> 1;

	if(l <= mid) lazy(o->ch[0], l, r, k);

	if(r > mid) lazy(o->ch[1], l, r, k);

	o->upd();

}

int query(Tree *o, int l, int r) {

	if(l <= o->l && o->r <= r) return o->max;

	int max = 0;

	o->dwn();

	int mid = (o->l + o->r) >> 1;

	if(l <= mid) max = std::max(max, query(o->ch[0], l, r));

	if(r > mid) max = std::max(max, query(o->ch[1], l, r));

	return max;

}

node *findroot(node *x) {

	while(x->ch[0]) x = x->ch[0];

	return x;

}

void access(node *x) {

	node *v;

	for(node *y = NULL; x; x = (y = x)->fa) {

		splay(x);

		if(x->ch[1]) v = findroot(x->ch[1]), lazy(root, dfn[v - pool], dfn[v - pool] + siz[v - pool] - 1, 1);

		if((x->ch[1] = y)) v = findroot(y), lazy(root, dfn[v - pool], dfn[v - pool] + siz[v - pool] - 1, -1);

	}

}

int LCA(int x, int y) {

	if(dep[x] < dep[y]) std::swap(x, y);

	for(int i = 17; i >= 0; i--) if(dep[f[x][i]] >= dep[y]) x = f[x][i];

	if(x == y) return x;

	for(int i = 17; i >= 0; i--) if(f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];

	return f[x][0];

}

int main() {

	n = in(), m = in();

	int p, x, y;

	for(int i = 1; i < n; i++) x = in(), y = in(), add(x, y), add(y, x);

	dfs(1, 0), build(root, 1, n), pool[1].fa = NULL;

	for(int j = 1; j <= 17; j++)

		for(int i = 1; i <= n; i++)

			f[i][j] = f[f[i][j - 1]][j - 1];

	while(m --> 0) {

		p = in();

		if(p == 1) access(pool + in());

		if(p == 2) {

			x = in(), y = in();

			int lca = LCA(x, y);

			printf("%d\n", query(root, dfn[x], dfn[x]) + query(root, dfn[y], dfn[y]) - 2 * query(root, dfn[lca], dfn[lca]) + 1);

		}

		if(p == 3) x = in(), printf("%d\n", query(root, dfn[x], dfn[x] + siz[x] - 1));

	}

	return 0;

}