BZOJ 2243: [SDOI2011]染色 树链剖分+线段树区间合并

2243: [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 <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5+10, M = 30005, mod = 1e9 + 7, inf = 0x3f3f3f3f;
typedef long long ll;

int t=1,n,head[N],q,pos[N],siz[N],deep[N],fa[N][19],belong[N],vis[N],sz,v[N];

struct ss{int to,next;}e[N*5];
struct seg{int l,r,lc,rc,s,tag;}tr[N*8];

void add(int u,int v) {e[t].next = head[u];e[t].to = v;head[u]=t++;}

//树链
void dfs1(int x) {
    siz[x]=1;vis[x]=1;
    for(int i=1;i<=17;i++) {
        if(deep[x] < (1<<i)) break;
        fa[x][i] = fa[fa[x][i-1]][i-1];
    }
    for(int i=head[x];i;i=e[i].next) {
        if(vis[e[i].to]) continue;
        deep[e[i].to] = deep[x]+1;
        fa[e[i].to][0] = x;
        dfs1(e[i].to);
        siz[x]+=siz[e[i].to];
    }
}

void dfs2(int x,int chain) {
    int k=0;
    sz++;
    pos[x]=sz;
    belong[x]=chain;
    for(int i=head[x];i;i=e[i].next)
        if(deep[e[i].to]>deep[x]&&siz[e[i].to]>siz[k]) k=e[i].to;
    if(k==0)return ;
    dfs2(k,chain);
    for(int i=head[x];i;i=e[i].next) //其他儿子划分链
        if(deep[e[i].to]>deep[x]&&e[i].to!=k) dfs2(e[i].to,e[i].to);
}
//lca
int lca(int x,int y) {
    if(deep[x]<deep[y]) swap(x,y);
    int t=deep[x]-deep[y];
    for(int i=0;i<=17;i++) if(t&(1<<i)) x=fa[x][i];
    for(int i=17;i>=0;i--)
        if(fa[x][i]!=fa[y][i]) {
            x=fa[x][i];
            y=fa[y][i];
        }
    if(x==y) return x;
    return fa[x][0];
}

//线段树部分
void build(int k,int s,int t) {
    tr[k].l = s;
    tr[k].r = t;
    tr[k].tag = -1;
    tr[k].s = 1;
    if(s==t) {
     return ;
    }
    int mid = (s+t)>>1;
    build(k<<1,s,mid);
    build(k<<1|1,mid+1,t);
}
void pushdown (int k) {
    if(tr[k].tag==-1||tr[k].l==tr[k].r) return ;
    tr[k<<1].s=tr[k<<1|1].s = 1;
    tr[k<<1].tag = tr[k].tag;
    tr[k<<1|1].tag = tr[k].tag;
    tr[k<<1].lc = tr[k<<1].rc = tr[k].tag;
    tr[k<<1|1].lc = tr[k<<1|1].rc = tr[k].tag;
    tr[k].tag = -1;
}
void pushup(int k) {
    tr[k].lc = tr[k<<1].lc;
    tr[k].rc = tr[k<<1|1].rc;
    if(tr[k<<1].rc^tr[k<<1|1].lc) {
        tr[k].s = tr[k<<1].s+tr[k<<1|1].s;
    }
    else {
        tr[k].s = tr[k<<1].s+tr[k<<1|1].s-1;
    }
}
void update(int k,int s,int t,int c) {
    pushdown(k);
    if(s==tr[k].l&&t==tr[k].r) {
        tr[k].lc = tr[k].rc = c;
        tr[k].tag = c;
        tr[k].s = 1;return ;
    }
    int mid = (tr[k].l+tr[k].r)>>1;
    if(t<=mid) update(k<<1,s,t,c);
    else if(s>mid) update(k<<1|1,s,t,c);
    else {
        update(k<<1,s,mid,c);
        update(k<<1|1,mid+1,t,c);
    }
    pushup(k);
}
int ask(int k,int s,int t) {
    pushdown(k);
    if(s==tr[k].l&&t==tr[k].r) {
        return tr[k].s;
    }
    int mid = (tr[k].l+tr[k].r)>>1;
    if(t<=mid) return ask(k<<1,s,t);
    else if(s>mid) return ask(k<<1|1,s,t);
    else {
        int tmp = 1;
        if(tr[k<<1].rc^tr[k<<1|1].lc) tmp = 0;
        return ask(k<<1,s,mid)+ask(k<<1|1,mid+1,t)-tmp;
    }
}
//

int getc(int k,int x) {
    pushdown(k);
    if(tr[k].l==tr[k].r) return tr[k].lc;
    int mid = (tr[k].l+tr[k].r)>>1;
    if(x <= mid ) return getc(k<<1,x);
    else return getc(k<<1|1,x);
}
 int solveask(int x,int f) {
    int sum = 0;
    while(belong[x]!=belong[f]) {
        sum+=ask(1,pos[belong[x]],pos[x]);
        if(getc(1,pos[belong[x]])==getc(1,pos[fa[belong[x]][0]])) sum--;
        x = fa[belong[x]][0];
    }
    sum+=ask(1,pos[f],pos[x]);
    return sum;
}
void solvechange(int x,int f,int c) {
    while(belong[x]!=belong[f]) {
        update(1,pos[belong[x]],pos[x],c);
        x = fa[belong[x]][0];
    }
    update(1,pos[f],pos[x],c);
}

void solve() {
    build(1,1,n);
    for(int i=1;i<=n;i++) {
        update(1,pos[i],pos[i],v[i]);
    }
    char ch[230];
    for(int i=1;i<=q;i++) {
            int x,y,c;
        scanf("%s%d%d",ch,&x,&y);
        if(ch[0]=='Q') {
            int t = lca(x,y);
            printf("%d\n",solveask(x,t)+solveask(y,t)-1);
        }
        else {
            scanf("%d",&c);
            int t = lca(x,y);
            solvechange(x,t,c);
            solvechange(y,t,c);
        }
    }
}
void init() {
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++) scanf("%d",&v[i]);
    for(int i=1;i<n;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
}
int main() {
    init();
    dfs1(1);
    dfs2(1,1);
    solve();
    return 0;
}