SDOI2017 树点涂色——LCT the END

Description

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

径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作：

1 x:

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

2 x y:

求x到y的路径的权值。

3 x y:

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

Bob一共会进行m次操作

 

Input

第一行两个数n,m。

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

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

1<=n,m<=100000

 

Output

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

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

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

 

Sample Input

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

Sample Output

3
4
2
2

　　　　　　　　--by BZOJ

http://www.lydsy.com/JudgeOnline/problem.php?id=4817

---

---

大概自己也没想到会回来写这道题吧。

一直对之前见到的，没做出来的题挺抵触的，

不过这是不对的，

题做不出来，也正常，

谁还能把所有的题全做出来呢，

况且，我见到这个题时还不会LCT，

我当时已经打出了树链剖分做法的全部了，

当然爆了一两个点的栈，SD的省选嘛，

然而自己弱是不应该找理由的，

题做不出来就是弱，

没理由的，

那就不应该逃避了，

那么，如果我没有死，你们都将看到我；

---

---

如果用LCT记录颜色个数的话，会非常僵，大概只能解决树链剖分解决的问题，

也就是操作三之外的；

但在观察每一个时期树上的颜色情况，发现与LCT的结构类似；

于是考虑利用LCT的结构维护颜色；

对于一二操作；

一就是从某点ACCESS；

二就是从某点空跑ACCESS而不改变splay的组成；

考虑一对三的影响：

发现在ACCESS连接两个点时，父方的点的原儿子的子树到根的颜色数+1，儿子方的点自己的子树颜色树减一；

维护线段树即可；

代码：

 #include<cstdio>
 using namespace std;
 int max[],mark[],rank[],dep[],size[],a[];
 struct dt{
     int fa,ch[];
 }data[];
 struct ss{
     int to,next;
 }e[];
 int first[],num;
 int n,m;
 void build(int ,int );
 void dfs(int ,int ,int );
 void builine(int ,int ,int );
 void access(int );
 int find_top(int );
 void splay(int );
 void roll(int );
 void find(int ,int );
 void add(int ,int ,int ,int ,int ,int );
 int ans(int ,int ,int ,int ,int );
 void down(int );
 inline void in(int &ans)
 {
     ans=;bool p=false;char ch=getchar();
     while((ch>'' || ch<'')&&ch!='-') ch=getchar();
     if(ch=='-') p=true,ch=getchar();
     while(ch<=''&&ch>='') ans=ans*+ch-'',ch=getchar();
     if(p) ans=-ans;
 }
 int main()
 {
     int i,j,k,x,y;
     in(n),in(m);
     for(i=;i<=n-;i++){
         in(j),in(k);
         build(j,k);build(k,j);
     }
     num=;dfs(,,);
     num=;builine(,n,);
     for(i=;i<=m;i++){
         in(j);
         if(j==){
             in(x);
             access(x);
         }
         if(j==){
             in(x),in(y);
             find(x,y);
         }
         if(j==){
             in(x);
             y=ans(,n,,rank[x],rank[x]+size[x]-);
             printf("%d\n",y);
         }
     }
     return ;
 }
 void build(int f,int t){
     e[++num].next=first[f];
     e[num].to=t;
     first[f]=num;
 }
 void dfs(int now,int d,int fa){
     int i;
     dep[now]=d;size[now]=;rank[now]=++num;a[num]=now;data[now].fa=fa;
     for(i=first[now];i;i=e[i].next)
         if(e[i].to!=fa){
             dfs(e[i].to,d+,now);
             size[now]+=size[e[i].to];
         }
 }
 void builine(int l,int r,int nu){
     if(l==r){
         max[nu]=dep[a[++num]];
         return ;
     }
     int mid=(l+r)>>;
     builine(l,mid,nu<<);
     builine(mid+,r,nu<<|);
     max[nu]=max[nu<<]>max[nu<<|]?max[nu<<]:max[nu<<|];
 }
 void access(int x){
     int y=,z;
     while(x){
         splay(x);z=find_top(y);
         if(z)add(,n,,rank[z],rank[z]+size[z]-,-);
         z=data[x].ch[];
         data[x].ch[]=y;
         y=x;x=data[x].fa;
         z=find_top(z);
         if(z)add(,n,,rank[z],rank[z]+size[z]-,);
     }
 }
 int find_top(int x){
     splay(x);
     while(data[x].ch[])
         x=data[x].ch[];
     return x;
 }
 void splay(int x){
     if(!x)return ;
     int fa,fafa;
     fa=data[x].fa;fafa=data[fa].fa;
     for(;data[fa].ch[]==x||data[fa].ch[]==x;roll(x),fa=data[x].fa,fafa=data[fa].fa){
         if(data[fafa].ch[]==fa||data[fafa].ch[]==fa){
             if((data[fafa].ch[]==fa)^(data[fa].ch[]==x))
                 roll(x);
             else
                 roll(fa);
         }
     }
 }
 void roll(int now){
     int fa=data[now].fa,fafa=data[fa].fa,wh=data[fa].ch[]==now;
     data[fa].ch[wh]=data[now].ch[wh^];data[data[fa].ch[wh]].fa=fa;
     data[now].ch[wh^]=fa;data[fa].fa=now;
     data[now].fa=fafa;
     if (data[fafa].ch[]==fa||data[fafa].ch[]==fa)
         data[fafa].ch[data[fafa].ch[]==fa]=now;
 }
 void find(int x,int y){
     int ans=;
     x=find_top(x);y=find_top(y);
     while(x!=y){
         if(dep[x]>dep[y]){
             splay(x);x=find_top(data[x].fa);ans++;
         }
         else{
             splay(y);y=find_top(data[y].fa);ans++;
         }
     }
     printf("%d\n",ans);
 }
 void add(int l,int r,int nu,int L,int R,int x){
     if(L<=l&&r<=R){
         max[nu]+=x;
         mark[nu]+=x;
         return ;
     }
     int mid=(l+r)>>;
     down(nu);
     if(L<=mid)
         add(l,mid,nu<<,L,R,x);
     if(R>mid)
         add(mid+,r,nu<<|,L,R,x);
     max[nu]=max[nu<<]>max[nu<<|]?max[nu<<]:max[nu<<|];
 }
 int ans(int l,int r,int nu,int L,int R){
     if(L<=l&&r<=R)
         return max[nu];
     int mid=(l+r)>>,lm=,rm=;
     down(nu);
     if(L<=mid)
         lm=ans(l,mid,nu<<,L,R);
     if(R>mid)
         rm=ans(mid+,r,nu<<|,L,R);
     if(lm>rm)return lm;
     return rm;
 }
 void down(int nu){
     if(!mark[nu])return;
     max[nu<<]+=mark[nu];max[nu<<|]+=mark[nu];
     mark[nu<<]+=mark[nu];mark[nu<<|]+=mark[nu];
     mark[nu]=;
 }