[bzoj4817][LCT][线段树]树点涂色

Description

Bob有一棵n个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。定义一条路
径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作： 1 x:
把点x到根节点的路径上所有的点染上一种没有用过的新颜色。 2 x y: 求x到y的路径的权值。 3 x
在以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

题解

我怎么这么菜啊..
没有第三个操作的话可以树剖过的..、
维护每个点到根的答案
先观察第一个操作
发现
这很像LCT的access操作
因为都是把根到某个点的一段路径提取出来
当割断一条重边的时候，我们把重边连接的下端端点子树答案全部减一
连接一条轻边的时候，我们把轻边连接的下端端点子树答案全部加一
每个点的答案其实就是他到根上的轻边数量加一
统计路径答案的时候就是$dep[x]+dep[y]-2*dep[LCA]-1$
分LCA是否是一条链的起始端讨论即可得证
写线段树维护就行了..
注意access的时候不能加splay的子树，要加原树的子树
所以先往左找到根再更新

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#define lc now<<1
#define rc now<<1|1
using namespace std;
struct node{int x,y,next;}a[210000];int len,last[110000];
void ins(int x,int y){len++;a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;}
int fa[110000][25],bin[25],dep[110000],ys[110000],tot[110000],z;
void pre_tree_node(int x)
{
    ys[x]=++z;tot[x]=1;
    for(int i=1;bin[i]<=dep[x];i++)fa[x][i]=fa[fa[x][i-1]][i-1];
    for(int k=last[x];k;k=a[k].next)
    {
        int y=a[k].y;
        if(y!=fa[x][0])
        {
            fa[y][0]=x;dep[y]=dep[x]+1;
            pre_tree_node(y);
            tot[x]+=tot[y];
        }
    }
}
int lca(int x,int y)
{
    if(dep[x]<dep[y])swap(x,y);
    for(int i=20;i>=0;i--)if(bin[i]<=dep[x]&&dep[fa[x][i]]>=dep[y])x=fa[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;i--)if(bin[i]<=dep[x]&&fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
int mx[810000],lazy[810000];
void pushup(int now)
{
    lazy[lc]+=lazy[now];lazy[rc]+=lazy[now];
    mx[lc]+=lazy[now];mx[rc]+=lazy[now];
    lazy[now]=0;
}
void ch(int now,int l,int r,int ql,int qr,int c)
{
    if(l==ql&&r==qr){mx[now]+=c;lazy[now]+=c;return ;}
    int mid=(l+r)/2;
    if(lazy[now]!=0)pushup(now);
    if(qr<=mid)ch(lc,l,mid,ql,qr,c);
    else if(mid+1<=ql)ch(rc,mid+1,r,ql,qr,c);
    else ch(lc,l,mid,ql,mid,c),ch(rc,mid+1,r,mid+1,qr,c);
    mx[now]=max(mx[lc],mx[rc]); 
}
int findmx(int now,int l,int r,int ql,int qr)
{
    if(qr<=0)return 0;
    if(l==ql&&r==qr)return mx[now];
    int mid=(l+r)/2;
    if(lazy[now]!=0)pushup(now);
    if(qr<=mid)return findmx(lc,l,mid,ql,qr);
    else if(mid+1<=ql)return findmx(rc,mid+1,r,ql,qr);
    else return max(findmx(lc,l,mid,ql,mid),findmx(rc,mid+1,r,mid+1,qr));
}
struct lct
{
    int son[2],f;
}tr[110000];
void rotate(int x,int w)
{
    int R,r;
    int f=tr[x].f,ff=tr[f].f;
    R=f;r=tr[x].son[w];
    tr[R].son[1-w]=r;
    if(r!=0)tr[r].f=R;
    R=ff;r=x;
    if(tr[R].son[0]==f)tr[R].son[0]=r;
    else if(tr[R].son[1]==f)tr[R].son[1]=r;
    tr[r].f=R;
    R=x;r=f;
    tr[R].son[w]=r;
    tr[r].f=R;
}
void splay(int x,int rt)
{
    while(tr[x].f!=rt &&(tr[tr[x].f].son[0]==x||tr[tr[x].f].son[1]==x))
    {
        int f=tr[x].f,ff=tr[f].f;
        if(ff==rt||(tr[ff].son[0]!=f&&tr[ff].son[1]!=f))
        {
            if(tr[f].son[0]==x)rotate(x,1);
            else rotate(x,0);
        }
        else
        {
            if(tr[ff].son[0]==f&&tr[f].son[0]==x)rotate(f,1),rotate(x,1);
            else if(tr[ff].son[1]==f&&tr[f].son[0]==x)rotate(x,1),rotate(x,0);
            else if(tr[ff].son[1]==f&&tr[f].son[1]==x)rotate(f,0),rotate(x,0);
            else rotate(x,0),rotate(x,1);
        }
    }
}
int n,m;
int getroot(int x)
{
    while(tr[x].son[0])x=tr[x].son[0];
    return x;
}
void access(int x)
{
    int y=0;
    while(x!=0)
    {
        splay(x,0);
        if(tr[x].son[1])
        {
            int gg=getroot(tr[x].son[1]);
            ch(1,1,n,ys[gg],ys[gg]+tot[gg]-1,1);
        }
        tr[x].son[1]=y;
        if(y!=0)
        {
            tr[y].f=x;
            int gg=getroot(y);
            ch(1,1,n,ys[gg],ys[gg]+tot[gg]-1,-1);
        }
        y=x;x=tr[x].f;
    }
}
int main()
{
    bin[0]=1;for(int i=1;i<=20;i++)bin[i]=bin[i-1]<<1;
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
    {
        int x,y;scanf("%d%d",&x,&y);
        ins(x,y);ins(y,x);
    }
    pre_tree_node(1);
    for(int i=1;i<=n;i++)ch(1,1,n,ys[i],ys[i],dep[i]),tr[i].f=fa[i][0];
    while(m--)
    {
        int op,u,v;scanf("%d%d",&op,&u);
        if(op==1)
            access(u);
        else if(op==2)
        {
            scanf("%d",&v);
            int LA=lca(u,v),s1=findmx(1,1,n,ys[u],ys[u]),s2=findmx(1,1,n,ys[v],ys[v]);
            int s3=findmx(1,1,n,ys[LA],ys[LA]);
            printf("%d\n",s1+s2-2*s3+1);
        }
        else printf("%d\n",findmx(1,1,n,ys[u],ys[u]+tot[u]-1)+1);
    }
    return 0;
}