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;

}