BZOJ-2243: [SDOI2011]染色-树链剖分_sdoi染色重链剖分-优快云博客

本文介绍了一种解决树形结构中路径染色与颜色段查询问题的方法，利用树链剖分结合线段树的数据结构实现高效操作。

http://www.lydsy.com/JudgeOnline/problem.php?id=2243

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）路径上的颜色段数量。

树链剖分:

按照套路，线段树维护的是sum,lc,rc,add,分别是，答案，区间最左端颜色，右端颜色，cover标记

push_up：

sum[i] =  (sum[i << 1] +sum[i << 1 | 1])-(rc[i<<1]==lc[i<<1|1]);
        lc[i]=lc[i<<1];
        rc[i]=rc[i<<1|1];

即两个子区间的颜色数相加，再看他们交接部分是否同色，是则再减一

这样只是解决了在同一条链上的颜色段数量，对于不同链，还要判断是否在交界部分为同色，这里我就简单粗暴直接查询fa[top[u]]和top[u]的颜色是否一致，是则答案减一

本题颜色范围【0，1e9】，所以初始化为-1

Memory	Time	Language	Code_Length	Submit_Time
1582805	liuyuhong	2243	Accepted	24456 kb	8316 ms	C++/Edit	6827 B	2016-08-10 01:53:31

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long ll;
const int MAXN = 100000+50;
struct Edge
{
    int to,next;
} edge[MAXN*2];
int head[MAXN],tot;
int top[MAXN];//top[v]表示v所在的重链的顶端节点
int fa[MAXN]; //父亲节点
int deep[MAXN];//深度
int num[MAXN];//num[v]表示以v为根的子树的节点数
int p[MAXN];//p[v]表示v与其父亲节点的连边在线段树中的位置
int fp[MAXN];//和p数组相反
int son[MAXN];//重儿子
int pos;
int id;
int in[MAXN];
int out[MAXN];//
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
    pos = 0;
    memset(son,-1,sizeof(son));
}
void addedge(int u,int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void dfs1(int u,int pre,int d) //第一遍dfs求出fa,deep,num,son
{
    deep[u] = d;
    fa[u] = pre;
    num[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != pre)
        {
            dfs1(v,u,d+1);
            num[u] += num[v];
            if(son[u] == -1 || num[v] > num[son[u]])
                son[u] = v;
        }
    }
}
void getpos(int u,int sp) //第二遍dfs求出top和p
{
    top[u] = sp;
    p[u] = ++pos;
    fp[p[u]] = u;
    if(son[u]!=-1)
        getpos(son[u],sp);
    for(int i = head[u] ; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v != son[u] && v != fa[u])
            getpos(v,v);
    }
    out[u]=pos;
}
struct TREE
{
    ll  sum[4*MAXN],add[4*MAXN],lc[4*MAXN],rc[4*MAXN];
    void build(int l,int r,int i)    //  线段树的建立；
    {
        add[i]=-1;
        sum[i]=0;
        lc[i]=rc[i]=-1;
        if(l==r) return;
        int mid=(l+r)>>1;
        build(l,mid,i<<1);
        build(mid+1,r,i<<1|1);
    }
    void pushDown(int i, int l, int r)		//把i节点的延迟标记传递到左右儿子节点
    {
        if(add[i] != -1)
        {
            int mid = (l + r) >> 1;
            add[i << 1]  = add[i];
            sum[i << 1]  = 1;
            lc[i << 1]  = add[i];
            rc[i << 1]  = add[i];
            add[i << 1 | 1]  = add[i];
            sum[i << 1 | 1]   = 1;
            lc[i << 1|1]  = add[i];
            rc[i << 1|1]  = add[i];
            add[i] = -1;
        }
    }
    void update(int i, int l, int r, int ql,int qr, ll val) //更新区间为qlqr,当前区间为l,r,代表当前区间和的节点为i，更新值为val,
    {
        if(l > qr ||ql > r)		//更新区间不在当前区间内
            return ;
        if(l >=ql && r <=qr )	//要更新的区间把当前区间完全包括，则把当前整个区间+val，然后返回上一层
        {
            sum[i] =1;
            add[i] =val;
            lc[i]  = add[i];
            rc[i]  = add[i];
            return ;
        }
        pushDown(i, l, r);			//如果上面没reutrn 表示要往左右儿子区间查询，所以把延迟标记放下去
        int mid = (l + r) >> 1;
        update(i << 1, l, mid, ql,qr, val);
        update(i << 1 | 1, mid + 1, r, ql,qr, val);
        sum[i] =  (sum[i << 1] +sum[i << 1 | 1])-(rc[i<<1]==lc[i<<1|1]);
        lc[i]=lc[i<<1];
        rc[i]=rc[i<<1|1];
    }
    int query_col(int i, int l, int r,int x )
    {
        if(l==x&&r==x)
        return add[i];
        pushDown(i, l, r);				//同update
        int mid =( l + r) >> 1;
        if (x<=mid) return query_col(i << 1, l, mid,x);
        else  return query_col(i << 1 | 1, mid + 1, r,x);

    }
    ll query(int i, int l, int r, int ql, int qr )	 //查询区间为qlqr,当前区间为l,r,代表当前区间和的节点为i
    {
        if(l > qr || ql > r)
            return 0;
        if(l >= ql && r <= qr)
        {
            return sum[i];
        }
        pushDown(i, l, r);				//同update
        int mid =( l + r) >> 1;
        int a1=query(i << 1, l, mid, ql, qr);
        int a2=query(i << 1 | 1, mid + 1, r, ql, qr);
        if (a1&&a2)
            return a1+a2-(rc[i<<1]==lc[i<<1|1] ) ;
        else if (a1) return a1;
        else return a2;

    }
    ll findsum(int u,int v)//查询u->v链的sum
    {

        int left,right;
        int f1=top[u],f2=top[v];
        ll tmp=0;
        while(f1!=f2)
        {
            if (deep[f1]<deep[f2])
            {
                swap(f1,f2);
                swap(u,v);
            }
            tmp+= query(1,1,pos,p[f1],p[u]);
            int last_col=query_col(1,1,pos,p[f1] );
            int nxt_col=query_col(1,1,pos,p[fa[f1]] );
            if (last_col==nxt_col) tmp--;
            u=fa[f1],f1=top[u];
        }
        if (deep[u]>deep[v] ) swap(u,v);
        return  (tmp+ query(1,1,pos,p[u],p[v])); //若val(u)是u到fu的边权,则用son[u]
    }
    void cover(int u,int v,int c)
    {
        int f1=top[u],f2=top[v];
        while(f1!=f2)
        {
            if (deep[f1]<deep[f2])
            {
                swap(f1,f2);
                swap(u,v);
            }
            update(1,1,pos,p[f1],p[u],c);
            u=fa[f1],f1=top[u];
        }
        if (deep[u]>deep[v] ) swap(u,v);
        return  update(1,1,pos,p[u],p[v],c); //若val(u)是u到fu的边权,则用son[u]
    }
};
TREE tp;
int a[MAXN];
int main()
{

    int n,m;
    init();
    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
        scanf("%d",&a[i]);
    int u,v,c;
    for (int i=1; i<n; i++)
    {
        scanf("%d%d",&u,&v);
        addedge(u,v);
        addedge(v,u);
    }
    dfs1(1,0,0);
    getpos(1,1);
    tp.build(1,pos,1);
    for (int i=1; i<=n; i++)
        tp.update(1,1,pos,p[i],p[i],a[i]); //son->fa的边权为e[i][2]


    char op[5];
    for (int i=1; i<=m; i++)
    {
        scanf("%s",op);
        if (op[0]=='C')
        {
            scanf("%d%d%d",&u,&v,&c);
            tp.cover(u,v,c);
        }
        else if (op[0]=='Q')
        {
            scanf("%d%d",&u,&v);
            printf("%d\n",tp.findsum(u,v));
        }

    }

    return 0;

}