BZOJ4817: [Sdoi2017]树点涂色(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构造。

将第一个操作视为access操作并更新答案。

那么开始时视为没有轻重链。

access过程中若发生轻重链转化时将子树答案都加1，并撤销上一节点操作。

这样就可以在每一个节点上维护到根的权值和。

第三问直接解决。

第二问呢，发现合并两条链的代价就是两个链单独的代价-2*lca代价+1（因为lca节点需要考虑）

子树修改普通Dfs就好了。

代码：

 

#include<cstdio>
#include<cstring>
#include<algorithm>
#define lll tr[spc].ch[0]
#define rrr tr[spc].ch[1]
#define ls ch[0]
#define rs ch[1]
typedef long long lnt;
const int N=300000;
struct seg_trnt{
    int lzt;
    int maxval;
}ter[N<<2];
struct spl_trnt{
    int ch[2];
    int fa;
    int lzt;
    bool anc;
}tr[N];
struct pnt{
    int hd;
    int dp;
    int ind;
    int oud;
    int fa[20];
}p[N];
struct ent{
    int twd;
    int lst;
}e[N<<1];
int n,m;
int cnt;
int dfn;
bool sta=true;
int pos[N];
void pushup(int spc)
{
    ter[spc].maxval=std::max(ter[spc<<1].maxval,ter[spc<<1|1].maxval);
    return ;
}
void ppushdown(int spc)
{
    if(ter[spc].lzt)
    {
        ter[spc<<1].maxval+=ter[spc].lzt;
        ter[spc<<1|1].maxval+=ter[spc].lzt;
        ter[spc<<1].lzt+=ter[spc].lzt;
        ter[spc<<1|1].lzt+=ter[spc].lzt;
        ter[spc].lzt=0;
    }
    return ;
}
void update(int l,int r,int ll,int rr,int spc,int v)
{
    if(ll>r||l>rr)
        return ;
    if(ll<=l&&r<=rr)
    {
        ter[spc].maxval+=v;
        ter[spc].lzt+=v;
        return ;
    }
    ppushdown(spc);
    int mid=(l+r)>>1;
    update(l,mid,ll,rr,spc<<1,v);
    update(mid+1,r,ll,rr,spc<<1|1,v);
    pushup(spc);
    return ;
}
int maxq(int l,int r,int ll,int rr,int spc)
{
    if(ll>r||l>rr)
        return -0x3f3f3f3f;
    if(ll<=l&&r<=rr)
        return ter[spc].maxval;
    int mid=(l+r)>>1;
    ppushdown(spc);
    return std::max(maxq(l,mid,ll,rr,spc<<1),maxq(mid+1,r,ll,rr,spc<<1|1));
}
int query(int l,int r,int pos,int spc)
{
    if(l==r)
        return ter[spc].maxval;
    ppushdown(spc);
    int mid=(l+r)>>1;
    if(pos<=mid)
        return query(l,mid,pos,spc<<1);
    return query(mid+1,r,pos,spc<<1|1);
}
void build(int l,int r,int spc)
{
    if(l==r)
    {
        ter[spc].maxval=p[pos[l]].dp;
        return ;
    }
    int mid=(l+r)>>1;
    build(l,mid,spc<<1);
    build(mid+1,r,spc<<1|1);
    pushup(spc);
    return ;
}
void ade(int f,int t)
{
    cnt++;
    e[cnt].twd=t;
    e[cnt].lst=p[f].hd;
    p[f].hd=cnt;
    return ;
}
void dfs(int x,int f)
{
    p[x].dp=p[f].dp+1;
    p[x].fa[0]=f;
    pos[++dfn]=x;
    p[x].ind=dfn;
    for(int i=1;i<=19;i++)
        p[x].fa[i]=p[p[x].fa[i-1]].fa[i-1];
    for(int i=p[x].hd;i;i=e[i].lst)
    {
        int to=e[i].twd;
        if(to==f)
            continue;
        tr[to].fa=x;
        dfs(to,x);
    }
    p[x].oud=dfn;
    return ;
}
int Lca(int x,int y)
{
    if(p[x].dp<p[y].dp)
        std::swap(x,y);
    for(int i=19;i>=0;i--)
    {
        if(p[p[x].fa[i]].dp>=p[y].dp)
            x=p[x].fa[i];
    }
    if(x==y)
        return x;
    for(int i=19;i>=0;i--)
    {
        if(p[x].fa[i]!=p[y].fa[i])
            x=p[x].fa[i],y=p[y].fa[i];
    }
    return p[x].fa[0];
}
bool whc(int spc)
{
    return tr[tr[spc].fa].rs==spc;
}
void trr(int spc)
{
    if(!spc)
        return ;
    std::swap(lll,rrr);
    tr[spc].lzt^=1;
    return ;
}
void pushdown(int spc)
{
    if(tr[spc].lzt)
    {
        tr[spc].lzt=0;
        trr(lll);
        trr(rrr);
    }
    return ;
}
void recal(int spc)
{
    if(!tr[spc].anc)
        recal(tr[spc].fa);
    pushdown(spc);
    return ;
}
void rotate(int spc)
{
    int f=tr[spc].fa;
    bool k=whc(spc);
    tr[f].ch[k]=tr[spc].ch[!k];
    tr[spc].ch[!k]=f;
    if(tr[f].anc)
    {
        tr[f].anc=0;
        tr[spc].anc=1;
    }else
        tr[tr[f].fa].ch[whc(f)]=spc;
    tr[spc].fa=tr[f].fa;
    tr[f].fa=spc;
    tr[tr[f].ch[k]].fa=f;
    return ;
}
void splay(int spc)
{
    recal(spc);
    while(!tr[spc].anc)
    {
        int f=tr[spc].fa;
        if(tr[f].anc)
        {
            rotate(spc);
            return ;
        }
        if(whc(spc)^whc(f))
            rotate(spc);
        else
            rotate(f);
        rotate(spc);
    }
    return ;
}
int leftpos(int spc)
{
    pushdown(spc);
    while(lll)
    {
        spc=lll;
        pushdown(spc);
    }
    return spc;
}
void access(int spc)
{
    int lst=0,x;
    while(spc)
    {
        splay(spc);
        tr[lst].anc=0;
        tr[rrr].anc=1;
        x=leftpos(rrr);
        if(x&&!sta)
            update(1,n,p[x].ind,p[x].oud,1,1);
        x=leftpos(lst);
        if(x&&!sta)
            update(1,n,p[x].ind,p[x].oud,1,-1);
        rrr=lst;
        lst=spc;
        spc=tr[spc].fa;
    }
    return ;
}
void Mtr(int spc)
{
    access(spc);
    splay(spc);
    trr(spc);
    return ;
}
void split(int x,int y)
{
    Mtr(x);
    access(y);
    splay(y);
    return ;
}
void link(int x,int y)
{
    split(x,y);
    tr[x].fa=y;
    return ;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        tr[i].anc=true;
    }
    for(int i=1;i<n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        ade(a,b);
        ade(b,a);
    }
    dfs(1,1);
    build(1,n,1);
    sta=false;
    while(m--)
    {
        int cmd;
        scanf("%d",&cmd);
        if(cmd==1)
        {
            int x;
            scanf("%d",&x);
            Mtr(1);
            access(x);
        }else if(cmd==2)
        {
            int ans=1;
            int x,y;
            scanf("%d%d",&x,&y);
            int z=Lca(x,y);
            ans+=query(1,n,p[x].ind,1);
            ans+=query(1,n,p[y].ind,1);
            ans-=query(1,n,p[z].ind,1)<<1;
            printf("%d\n",ans);
        }else{
            int x;
            scanf("%d",&x);
            printf("%d\n",maxq(1,n,p[x].ind,p[x].oud,1));
        }
    }
    return 0;
}