Description:
Bob有一棵\(n\)个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。
定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。
Bob可能会进行这几种操作：
\(1\) \(x\)
把点\(x\)到根节点的路径上所有的点染上一种没有用过的新颜色。
\(2\) \(x\) \(y\)
求\(x\)到\(y\)的路径的权值。
\(3\) \(x\)
在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值。
Bob一共会进行\(m\)次操作
Hint:
\(n,m\le 10^5\)
solution:
首先我们需要维护每个点到根的权值
2 操作可以直接 \(dis_u+dis_v-2*dis_{LCA}+1\)
3 操作用线段树维护子树最值
但直接做的话每次修改会把一条路径上的所有节点的子树都改一遍
单次 \(nlogn\) 复杂度爆炸
考虑其实一条路径上是若干段连续的颜色相等的区间
如果能维护这个东西 复杂度就可以变成 \(O(Color*logn) \approx O(log^2n)\)
因为每种颜色都是一条链 想到用 \(LCT\) 的每颗\(splay\) 维护一种颜色
这样我们修改时就方便得多
每次对一个点 \(access\)
对于父亲节点之前的儿子的子树权值整体 \(+1\)
对于当前节点子树权值整体 \(-1\)
就可以了 复杂度 \(O(nlog^2n)\)
#include <map>
#include <set>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define ls p<<1
#define rs p<<1|1
using namespace std;
typedef long long ll;
const int mxn=1e5+5;
int n,m,cnt,hd[mxn],fa[mxn],ch[mxn][2];
struct ed {
int to,nxt;
}t[mxn<<1];
inline void add(int u,int v) {
t[++cnt]=(ed) {v,hd[u]}; hd[u]=cnt;
}
inline int read() {
char c=getchar(); int x=0,f=1;
while(c>'9'||c<'0') {if(c=='-') f=-1;c=getchar();}
while(c<='9'&&c>='0') {x=(x<<3)+(x<<1)+(c&15);c=getchar();}
return x*f;
}
inline void chkmax(int &x,int y) {if(x<y) x=y;}
inline void chkmin(int &x,int y) {if(x>y) x=y;}
int tot,f[mxn],sz[mxn],rk[mxn],top[mxn],son[mxn],dep[mxn],dfn[mxn];
int tr[mxn<<2],tag[mxn<<2];
namespace Seg {
void push_up(int p) {
tr[p]=max(tr[ls],tr[rs]);
}
void push_down(int p) {
if(tag[p]) {
tag[ls]+=tag[p];
tag[rs]+=tag[p];
tr[ls]+=tag[p];
tr[rs]+=tag[p];
tag[p]=0;
}
}
void dfs1(int u,int fa) {
dep[u]=dep[fa]+1; f[u]=fa; sz[u]=1;
for(int i=hd[u];i;i=t[i].nxt) {
int v=t[i].to;
if(v==fa) continue ;
dfs1(v,u); sz[u]+=sz[v];
if(sz[son[u]]<sz[v]) son[u]=v;
}
}
void dfs2(int u,int tp) {
dfn[u]=++tot; rk[tot]=u; top[u]=tp;
if(son[u]) dfs2(son[u],tp),fa[son[u]]=u;
for(int i=hd[u];i;i=t[i].nxt) {
int v=t[i].to;
if(v==f[u]||v==son[u]) continue ;
dfs2(v,v); fa[v]=f[v];
}
}
void build(int l,int r,int p) {
if(l==r) {
tr[p]=dep[rk[l]];
return ;
}
int mid=(l+r)>>1;
build(l,mid,ls);
build(mid+1,r,rs);
push_up(p);
}
int LCA(int x,int y) {
while(top[x]!=top[y]) {
if(dep[top[x]]<dep[top[y]]) swap(x,y);
x=f[top[x]];
}
return dep[x]<dep[y]?x:y;
}
void update(int l,int r,int ql,int qr,int val,int p) {
if(ql<=l&&r<=qr) {
tr[p]+=val;
tag[p]+=val;
return ;
}
int mid=(l+r)>>1; push_down(p);
if(ql<=mid) update(l,mid,ql,qr,val,ls);
if(qr>mid) update(mid+1,r,ql,qr,val,rs);
push_up(p);
}
int query(int l,int r,int ql,int qr,int p) {
if(ql<=l&&r<=qr) return tr[p];
int mid=(l+r)>>1; push_down(p); int res=0;
if(ql<=mid) chkmax(res,query(l,mid,ql,qr,ls));
if(qr>mid) chkmax(res,query(mid+1,r,ql,qr,rs));
push_up(p); return res;
}
int ask(int x) {return query(1,n,dfn[x],dfn[x],1);}
}
using namespace Seg;
namespace lct {
int isnotrt(int x) {
return ch[fa[x]][0]==x||ch[fa[x]][1]==x;
}
void rotate(int x) {
int y=fa[x],z=fa[y],tp=ch[y][1]==x;
if(isnotrt(y)) ch[z][ch[z][1]==y]=x; fa[x]=z;
ch[y][tp]=ch[x][tp^1]; fa[ch[x][tp^1]]=y;
ch[x][tp^1]=y; fa[y]=x;
}
void splay(int x) {
while(isnotrt(x)) {
int y=fa[x],z=fa[y];
if(isnotrt(y))
(ch[y][1]==x)^(ch[z][1]==y)?rotate(x):rotate(y);
rotate(x);
}
}
void access(int x) {
for(int y=0;x;x=fa[y=x]) {
splay(x);
if(ch[x][1]) { //这里是本题重点
int pos=ch[x][1]; while(ch[pos][0]) pos=ch[pos][0];
update(1,n,dfn[pos],dfn[pos]+sz[pos]-1,1,1);
}
ch[x][1]=y;
if(ch[x][1]) {
int pos=ch[x][1]; while(ch[pos][0]) pos=ch[pos][0];
update(1,n,dfn[pos],dfn[pos]+sz[pos]-1,-1,1);
}
}
}
}
using namespace lct;
int main()
{
n=read(); m=read(); int opt,x,y,u,v;
for(int i=1;i<n;++i) {
u=read(); v=read();
add(u,v); add(v,u);
}
dfs1(1,0); dfs2(1,1); build(1,n,1);
for(int i=1;i<=m;++i) {
opt=read();
if(opt==1) x=read(),access(x);
else if(opt==2) {
x=read(); y=read(); int lca=LCA(x,y);
printf("%d\n",ask(x)+ask(y)-2*ask(lca)+1);
}
else x=read(),printf("%d\n",query(1,n,dfn[x],dfn[x]+sz[x]-1,1));
}
return 0;
}