P2486 [SDOI2011]染色

传送门

题目描述

输入输出格式

输入格式：

输出格式：

 

对于每个询问操作，输出一行答案。

 

输入输出样例

输入样例#1： 

6 5
2 2 1 2 1 1
1 2
1 3
2 4
2 5
2 6
Q 3 5
C 2 1 1
Q 3 5
C 5 1 2
Q 3 5

输出样例#1：

3
1
2

说明

这是树剖初学者必打的一道题目，很基础，但很难调，根据机房的大佬的说法，

如果树剖错了就重打吧，别改了。。。

思路：

一看就知道是棵树，可以通过树链剖分后维护。颜色就相当于点权，强烈暗示树链剖分。

所以这是很好的一道树链剖分。

所以重点就落在了如何维护区间颜色块数？

我们可以这样考虑：我们考虑小区间与小区间是不是可以合并

假如我们已经知道这左右两段的左右端点和各自的颜色块数，我们可以想象一下对接这两个区间，如果左半段右端点和右半段左端点是一样的话，合起来的区间就会比原来两段区间中颜色块数之和少一个颜色块。

合并的问题解决了，那如何算其中一个区间的颜色块数？

我们和刚刚的方法相似，就是把这个区间分开，然后按照刚刚的办法合并，合并时把同块的减掉，，

如果一直分下去，，是不是和什么数据结构有点类似，，，（其实这是废话树剖除了加线段树其他的真的不会。。。）

树剖后，线段树要记录左端点l,右端点r，左端点的颜色lc,右端点的颜色rc,区间成段更新的标记tag,区间有多少颜色段。区间合并的时候要注意如果左子树的右端和右子树的左端颜色相同那么数量要减一。但是存在一个问题当前剖到的链与上一次的链在相交的边缘可能颜色相同，如果颜色相同答案需要减一。所以统计答案的时候要记录下上一次剖到的链的左端点的颜色，与当前剖到的链右端点的颜色（因为在处理出的线段树中越靠近根的点位置越左），比较这两个颜色，若相同则答案减1。又由于有u和v两个位置在向上走，那么要记录ans1，ans2两个变量来存“上一次的左端点颜色”。有一点需要注意，当top[u]=top[v]的时候，即已经在同一个重链上时，两边端点颜色都要考虑与对应ans比较颜色，相同答案要相应减一。即如果右儿子的最左边颜色和左儿子的最右边颜色相同，那么肯定有中间部分属于同一颜色段。

详见代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=1e5+10;
struct node
{
    int next;
    int to;
    int from;
}way[maxn<<1];
struct rr
{
    int lc,rc;
    int l,r,num;
    int lazy;
}tree[maxn<<2];
int head[maxn];
int size[maxn];
int top[maxn];
int n,m;
int son[maxn];
char str[maxn];
int pre[maxn];
int LC,RC;
int father[maxn];
int summ[maxn];
int deep[maxn];
int tuop[maxn];
int tot;
int cnt;

int add(int x,int y)
{
    way[++tot].next=head[x];
    way[tot].to=y;
    way[tot].from=x;
    head[x]=tot;
}

void dfs1(int x,int fa)
{
    size[x]=1;
    for(int i=head[x];i;i=way[i].next)
    {
        int to=way[i].to;
        if(to==fa)
        continue;
        deep[to]=deep[x]+1;
        father[to]=x;
        dfs1(to,x);
        size[x]+=size[to];
        if(size[to]>size[son[x]])
        {
            son[x]=to;
        }
    }
}

void dfs2(int x,int tp)
{
    top[x]=tp;
    tuop[x]=++cnt;
    pre[cnt]=x;
    if(son[x])
    {
        dfs2(son[x],tp);
    }
    for(int i=head[x];i;i=way[i].next)
    {
        int to=way[i].to;
        if(to==father[x]||to==son[x])
        {
            continue;
        }
        dfs2(to,to);
    }
}

inline int pushdown(int x)
{
    if(tree[x].lazy)
    {
        tree[x<<1].lazy=tree[x<<1|1].lazy=tree[x].lazy;
        tree[x<<1].num=tree[x<<1|1].num=1;
        tree[x<<1].lc=tree[x<<1].rc=tree[x<<1|1].lc=tree[x<<1|1].rc=tree[x].lc;
        tree[x].lazy=0;
    }
}


inline int pushup(int x)
{
    tree[x].lc=tree[x<<1].lc;
    tree[x].rc=tree[x<<1|1].rc;
    int ans=tree[x<<1].num+tree[x<<1|1].num;
    if(tree[x<<1].rc==tree[x<<1|1].lc)
    {
        ans--;
    }
    tree[x].num=ans;
}

void build(int x,int l,int r)
{
    tree[x].l=l;
    tree[x].r=r;
    tree[x].num=0;
    if(l==r)
    {
        return ;
    }
    int mid=(l+r)>>1;
    build(x<<1,l,mid);
    build(x<<1|1,mid+1,r);
} 

void jia(int x,int l,int r,int c)
{
    if(tree[x].l==l&&tree[x].r==r)
    {
        tree[x].num=tree[x].lazy=1;
        tree[x].lc=tree[x].rc=c;
        return ;
    }
    pushdown(x);
    int mid=(tree[x].l+tree[x].r)>>1;
    if(r<=mid)
    jia(x<<1,l,r,c);
    else
    if(l>mid)
    jia(x<<1|1,l,r,c);
    else
    {
        jia(x<<1,l,mid,x);
        jia(x<<1|1,mid+1,r,c);
    }
    pushup(x);
}  

int cha(int x,int l,int r,int ls,int rs)
{
    if(tree[x].l==ls)
    LC=tree[x].lc;
    if(tree[x].r==rs)
    RC=tree[x].rc;
    if(tree[x].l==l&&tree[x].r==r)
    {
        return tree[x].num;
    }
    pushdown(x);
    int mid=(tree[x].l+tree[x].r)>>1;
    if(r<=mid)
    {
        return cha(x<<1,l,r,ls,rs);
    }
    else
    if(l>mid)
    {
        return cha(x<<1|1,l,r,ls,rs);
    }
    else
    {
        int ans=cha(x<<1,l,mid,ls,rs)+cha(x<<1|1,mid+1,r,ls,rs);
        if(tree[x<<1].rc==tree[x<<1|1].lc)
        {
            ans--;
        }
        return ans;
    }
    pushup(x);
}
int qcha1(int x,int to,int c)
{
    while(top[x]!=top[to])
    {
        if(deep[top[x]]<deep[top[to]])
        {
            swap(x,to);
        }
        jia(1,tuop[top[x]],tuop[x],c);
        x=father[top[x]];
    }
    if(deep[to]<deep[x])
    {
        swap(x,to);
    }
    jia(1,tuop[x],tuop[to],c);
}

int qcha2(int x,int to,int c)
{
    int ans=0;
    int ans1=-1;
    int ans2=-1;
    while(top[x]!=top[to])
    {
        if(deep[top[x]]<deep[top[to]])
        {
            swap(x,to);
            swap(ans1,ans2);
        }
        ans+=cha(1,tuop[top[x]],tuop[x],tuop[top[x]],tuop[x]);
        if(RC==ans1)
        ans--;
        ans1=LC;
        x=father[top[x]];
    }
    if(deep[x]<deep[to])
    {
        swap(x,to);
        swap(ans1,ans2);
    }
    ans+=cha(1,tuop[to],tuop[x],tuop[to],tuop[x]);
    if(RC==ans1)
    {
        ans--;
    }
    if(LC=ans2)
    {
        ans--;
    }
    return ans;
}    
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        cnt=tot=0;
        memset(head,-1,sizeof(head));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&summ[i]);
        }
        for(int i=1;i<n;i++)
        {
            int v,o;
            scanf("%d%d",&v,&o);
            add(v,o);
            add(o,v);
        }
        //cout<<"11111111111"<<endl;
        deep[1]=1;
        father[1]=1;
        dfs1(1,1);
        dfs2(1,1);
        build(1,1,n);
        for(int i=1;i<=n;i++)
        {
            jia(1,tuop[i],tuop[i],summ[i]);
        }
        //cout<<"111111111111111111111111111111111111111111111111"<<endl;
        while(m--)
        {
            scanf("%s",str);
            int u,v;
            if(str[0]=='C')
            {
                int c;
                cin>>u>>v>>c;
                qcha1(u,v,c);
            }
            else
            {
                int u,v;
                cin>>u>>v;
                cout<<qcha2(u,v,0);
            }
        }
    }
    return 0;
}