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]之间。

Source

第一轮day1

分析

树剖的好题，线段树要记录左右节点l,r,左右节点的颜色lc,rc，区间成段更新的标记tag,区间的颜色段数量s

区间合并的时候，x,y的lca(x,y)重复计算了两次，需要减1

如果左子树的右端和右子树的左端颜色相同那么数量要减1

当前剖到的链与上一次链相交的边缘可能相等，答案减1

剩下的就是纯树剖+线段树了

code

代码已经压行到很短了，但是依然4K

机房的常老师说他10分钟就能敲好调好一个树剖，简直太神了%%%

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read()
{
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int maxn=1e5+6,maxd=17;
int n,m,cnt,sz,last[maxn],deep[maxn],son[maxn],belong[maxn],pl[maxn],v[maxn],fa[maxn][maxd+1];
bool vis[maxn];
char ch[10];
struct tree{int l,r,lc,rc,s,tag;}t[maxn<<2];
struct edge{int to,next;}e[maxn<<1];

void insert(int u,int v){
    e[++cnt]=(edge){v,last[u]};last[u]=cnt;
    e[++cnt]=(edge){u,last[v]};last[v]=cnt;
}
void dfs1(int x){
    vis[x]=son[x]=1;
    rep(i,1,maxd){
        if(deep[x]<(1<<i))break;
        fa[x][i]=fa[fa[x][i-1]][i-1];
    }
    reg(x){
        if(vis[e[i].to])continue;
        deep[e[i].to]=deep[x]+1;
        fa[e[i].to][0]=x;//与自己的儿子节点建立关系 
        dfs1(e[i].to);
        son[x]+=son[e[i].to];//记录子节点个数 
    }
}
void dfs2(int x,int chain)
{
    pl[x]=++sz;belong[x]=chain;int k=0;
    reg(x)if(deep[e[i].to]>deep[x]&&son[k]<son[e[i].to])k=e[i].to;
    if(!k)return;dfs2(k,chain);
    reg(x)if(deep[e[i].to]>deep[x]&&k!=e[i].to)dfs2(e[i].to,e[i].to);
}
int lca(int x,int y){
    if(deep[x]<deep[y])swap(x,y);
    int tmp=deep[x]-deep[y];
    rep(i,0,maxd)if(tmp&(1<<i))x=fa[x][i];
    dep(i,maxd,0)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 l,int r)
{
    t[k].l=l;t[k].r=r;t[k].s=1;t[k].tag=-1;
    if(l==r)return;int mid=(l+r)>>1;
    build(k<<1,l,mid);build(k<<1|1,mid+1,r);
}
void pushup(int k)
{
    t[k].lc=t[k<<1].lc;t[k].rc=t[k<<1|1].rc;
    if(t[k<<1].rc^t[k<<1|1].lc)t[k].s=t[k<<1].s+t[k<<1|1].s;else t[k].s=t[k<<1].s+t[k<<1|1].s-1;
}
void pushdown(int k)
{
    int tmp=t[k].tag;t[k].tag=-1;
    if(tmp==-1||t[k].l==t[k].r)return;
    t[k<<1].s=t[k<<1|1].s=1;
    t[k<<1].tag=t[k<<1|1].tag=tmp;
    t[k<<1].lc=t[k<<1].rc=tmp;t[k<<1|1].lc=t[k<<1|1].rc=tmp;//同时下方颜色的lazy标记 
}
void change(int k,int x,int y,int c)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==x&&r==y){t[k].lc=t[k].rc=c;t[k].s=1;t[k].tag=c;return;}//lc和rc表示左端点和右端点的颜色 
    if(mid>=y)change(k<<1,x,y,c);
    else if(mid<x)change(k<<1|1,x,y,c);
    else{change(k<<1,x,mid,c);change(k<<1|1,mid+1,y,c);}
    pushup(k);
}
int ask(int k,int x,int y)
{
    pushdown(k);
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==x&&r==y)return t[k].s;
    if(mid>=y)return ask(k<<1,x,y);
    else if(mid<x)return ask(k<<1|1,x,y);
    else{
        int tmp=1;if(t[k<<1].rc^t[k<<1|1].lc)tmp=0;
        return ask(k<<1,x,mid)+ask(k<<1|1,mid+1,y)-tmp;
    }
}
int getc(int k,int x)//查询节点颜色 
{
    pushdown(k);
    int l=t[k].l,r=t[k].r,mid=(l+r)>>1;
    if(l==r)return t[k].lc;
    if(x<=mid)return getc(k<<1,x);
    else return getc(k<<1|1,x);
}
int solvesum(int x,int f)
{
    int sum=0;
    while(belong[x]!=belong[f]){
        sum+=ask(1,pl[belong[x]],pl[x]);
        if(getc(1,pl[belong[x]])==getc(1,pl[fa[belong[x]][0]]))sum--;//当前剖到的链与上一次的链在相交的边缘可能颜色相同，答案减1 
        x=fa[belong[x]][0]; 
    }
    sum+=ask(1,pl[f],pl[x]);
    return sum;
}
void solvechange(int x,int f,int c)
{
    while(belong[x]!=belong[f]){
        change(1,pl[belong[x]],pl[x],c);
        x=fa[belong[x]][0]; //倍增更改颜色 
    }
    change(1,pl[f],pl[x],c);
}
int main()
{
    n=read(),m=read();
    rep(i,1,n)v[i]=read();
    rep(i,1,n-1){
        int u=read(),v=read();
        insert(u,v);
    }
    dfs1(1);dfs2(1,1);build(1,1,n);//树剖两遍dfs 
    rep(i,1,n)change(1,pl[i],pl[i],v[i]);//将v[i]赋值给pl[i] 
    rep(i,1,m){
        scanf("%s",ch);
        if(ch[0]=='Q'){
            int a=read(),b=read(),t=lca(a,b);
            printf("%d\n",solvesum(a,t)+solvesum(b,t)-1);//查询路径上的颜色子段数量，减去lca(a,b)重复计算的1个 
        }
        else{
            int a=read(),b=read(),c=read(),t=lca(a,b);
            solvechange(a,t,c);solvechange(b,t,c);
        }
    }
    return 0;
}