BZOJ2243 SDOI2011 染色 【树链剖分】

BZOJ2243 SDOI2011 染色

---

Description

给定一棵有n个节点的无根树和m个操作，操作有2类：

1、将节点a到节点b路径上所有点都染成颜色c；

2、询问节点a到节点b路径上的颜色段数量（连续相同颜色被认为是同一段），

如“112221”由3段组成：“11”、“222”和“1”。

请你写一个程序依次完成这m个操作。

Input

第一行包含2个整数n和m，分别表示节点数和操作数；

第二行包含n个正整数表示n个节点的初始颜色

下面 行每行包含两个整数x和y，表示x和y之间有一条无向边。

下面 行每行描述一个操作：

“C a b c”表示这是一个染色操作，把节点a到节点b路径上所有点（包括a和b）都染成颜色c；

“Q a b”表示这是一个询问操作，询问节点a到节点b（包括a和b）路径上的颜色段数量。

Output

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

Sample Input

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

Sample Output

3

1

2

HINT

数N<=10^5，操作数M<=10^5，所有的颜色C为整数且在[0, 10^9]之间。

---

板子题，线段树维护一下左右端点颜色和色段个数就好了

注意在树链上跳的时候不要忘了合并区间，把链上相邻区间合并一下

---

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define N 200010
#define LD (o<<1)
#define RD ((o<<1)|1)
struct Tree{
    int l,r,sum;
    int lc,rc;//记录最左最右的颜色
    int cg;//记录更改
}T[N<<2];//线段树
struct Edge{int v,next;}E[N];//边
struct Node{
    int dep,siz,fa,w,hson,num,top;
    Node(){dep=siz=fa=w=hson=num=top=0;}
}P[N];//点
/*
dep深度
siz节点数
fa父亲
w节点权值
hson重孩子
num在线段树编号
top表示每条链第一个位置
*/
int first[N],pred[N];
/*
first 邻接表头指针
pred线段树的编号是原来什么编号
*/
int n,m,last,tot;//tot记录线段树总编号
void init(){
    last=tot=0;
    memset(first,0,sizeof(first));
    memset(pred,0,sizeof(pred));
}
inline int read(){
    long long data=0,w=1; char ch=0;
    while(ch!='-' && (ch<'0' || ch>'9')) ch=getchar();
    if(ch=='-') w=-1,ch=getchar();
    while(ch>='0' && ch<='9'){data=data*10+ch-'0';ch=getchar();}
    return data*w;
}
void add(int u,int v){
    E[++last].v=v;
    E[last].next=first[u];
    first[u]=last;
}
void dfs1(int u){
    P[u].siz=1;
    P[u].hson=0;
    for(int i=first[u];i;i=E[i].next){
        int &v=E[i].v;
        if(v==P[u].fa)continue;
        P[v].dep=P[u].dep+1;
        P[v].fa=u;
        dfs1(v);
        P[u].siz+=P[v].siz;
        if(P[P[u].hson].siz<P[v].siz)
            P[u].hson=v;
    }
}
void dfs2(int u,int tp){
    P[u].top=tp;
    P[u].num=++tot;
    pred[tot]=u;
    if(P[u].hson)dfs2(P[u].hson,tp);
    for(int i=first[u];i;i=E[i].next){
        int &v=E[i].v;
        if(v!=P[u].fa&&v!=P[u].hson)
            dfs2(v,v);
    }
}
void pushup(int o){
    T[o].lc=T[LD].lc;T[o].rc=T[RD].rc;
    T[o].sum=T[LD].sum+T[RD].sum;
    if(T[LD].rc==T[RD].lc)T[o].sum--;//左右区间相邻处颜色相同合为同一色段
}
void pushdown(int o){
    if(T[o].cg){
        int t=T[o].cg;
        T[LD].cg=T[RD].cg=t;
        T[LD].lc=T[LD].rc=t;
        T[RD].lc=T[RD].rc=t;
        T[o].lc=T[o].rc=t;
        T[LD].sum=T[RD].sum=T[o].sum=1;
        T[o].cg=0;
    }
}
void build(int o,int l,int r){
    T[o].l=l;T[o].r=r;
    if(l==r){
        T[o].lc=T[o].rc=-1;//P[pred[l]].w;
        T[o].sum=0;T[o].cg=-1;
        return;
    }
    int mid=(l+r)>>1;
    build(LD,l,mid);
    build(RD,mid+1,r);
}
void update(int o,int l,int r,int val){
    if(T[o].l>r||T[o].r<l)return;
    if(l<=T[o].l&&T[o].r<=r){
        T[o].cg=T[o].lc=T[o].rc=val;
        T[o].sum=1;
        return;
    }
    pushdown(o);
    int mid=(T[o].l+T[o].r)>>1;
    if(l<=mid)update(LD,l,r,val);
    if(r>=mid+1)update(RD,l,r,val);
    pushup(o);
}
Tree query(int o,int l,int r){
    if(l<=T[o].l&&T[o].r<=r)return T[o];
    pushdown(o);
    int mid=(T[o].l+T[o].r)>>1;
    if(mid>=r)return query(LD,l,r);
    if(mid<l)return query(RD,l,r);
    Tree ans;
    Tree LL=query(LD,l,mid);
    Tree RR=query(RD,mid+1,r);
    ans.l=LL.l;ans.r=RR.r;
    ans.lc=LL.lc;ans.rc=RR.rc;
    ans.sum=LL.sum+RR.sum;
    if(LL.rc==RR.lc)ans.sum--;
    return ans;
}
int get_sum(int x,int y){
    int lastx=-1,lasty=-1,ans=0;
    while(P[x].top!=P[y].top){
        if(P[x].num<P[y].num)swap(x,y),swap(lastx,lasty);
        Tree tmp=query(1,P[P[x].top].num,P[x].num);
        ans+=tmp.sum;
        if(lastx==tmp.rc)ans--;//左右区间相邻处颜色相同合为同一色段
        lastx=tmp.lc;
        x=P[P[x].top].fa;
    }
    if(P[x].num>P[y].num)swap(x,y),swap(lastx,lasty);
    Tree tmp=query(1,P[x].num,P[y].num);
    ans+=tmp.sum;
    if(lastx==tmp.lc)ans--;
    if(lasty==tmp.rc)ans--;
    return ans;
}
void get_update(int x,int y,int val){
    while(P[x].top!=P[y].top){
        if(P[x].num<P[y].num)swap(x,y);
        update(1,P[P[x].top].num,P[x].num,val);
        x=P[P[x].top].fa;
    }
    if(P[x].num>P[y].num)swap(x,y);
    update(1,P[x].num,P[y].num,val);
}
int main(){
    n=read();m=read();
    for(int i=1;i<=n;++i)P[i].w=read();
    for(int i=1;i<n;++i){
        int a=read(),b=read();
        add(a,b);
        add(b,a);
    }
    dfs1(1);
    dfs2(1,1);
    build(1,1,n);
    for(int i=1;i<=n;++i)update(1,P[i].num,P[i].num,P[i].w);
    for(int i=1;i<=m;++i){
        char t[3];int a,b,c;
        scanf("%s",t);a=read();b=read();
        if(t[0]=='Q')printf("%d\n",get_sum(a,b));
        if(t[0]=='C'){
            c=read();
            get_update(a,b,c);
        }
    }
    return 0;
}