HYSBZ 2243

Time Limit: 20000MS     Memory Limit: 524288KB     64bit IO Format: %lld & %llu

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

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

题目主要的难点就是在查询某一条链的时候  由于树剖可能将这条分成多条重链，所以在查询的时候要考虑在每查询一条链，看这条链是否跟其他重链连在一起，如果是连在一起的，判断相连的那两个节点颜色是否相同，如果相同就把ans-1。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <algorithm>
#define lson l,mid,o<<1
#define rson mid+1,r,o<<1|1
using namespace std;
const int maxn = 100005;
int n,m;
int son[maxn]; //表示该点重链的子节点
int num[maxn]; //表示以该点为根的子树的节点数量
int dep[maxn]; //表示该节点的深度
int fa[maxn];  // 表示该节点的父亲节点
int vis[maxn]; // 表示该节点在线段树中的编号
int top[maxn]; // 表示这条重链的顶端节点
int now;
int head[maxn],cnt,A,B,C;
struct Edge
{
    int v,next;
}e[maxn<<1];
void add(int a,int b)
{
    e[cnt].v = b;
    e[cnt].next = head[a];
    head[a] = cnt++;
}
void init()
{
    memset(head,-1,sizeof(head));
    memset(son,-1,sizeof(son));
    now = cnt = 0;
}
void dfs1(int u,int v,int step) //第一遍dfs求出son，fa，num，dep
{
    num[v] = 1;dep[v] = step;fa[v] = u;
    int i;
    for(i = head[v]; i != -1; i = e[i].next)
    {
        int end = e[i].v;
        if(end == u)
            continue;
        dfs1(v,end,step+1);
        if(son[v] == -1 || num[son[v]] < num[end])// 取子节点数量最多的点
        {
            son[v] = end;
        }
        num[v] += num[end];
    }
}
void dfs2(int u,int v)// 第二遍dfs求出top和vis
{
    top[v] = u;
    vis[v] = ++now; // 一个节点在线段树里面代表一个点
    if(son[v] != -1)  //将重链在线段树里连续编号
    {
        dfs2(u,son[v]);
    }
    else
        return;
    int i;
    for(i = head[v] ; i != -1; i = e[i].next)
    {
        int end = e[i].v;
        if(end == fa[v] || end == son[v])//等于父亲节点或者等于重链的子节点跳过，这里的u不是父亲节点，是重链的顶端
            continue;
        dfs2(end,end); // 所有轻链重新为其节点的重链编号
    }
}
int sum[maxn<<2],stal[maxn<<2],star[maxn<<2],odd[maxn<<2];
void down(int o,int len)
{
    if(odd[o] != -1)
    {
        sum[o << 1] = sum[o <<1|1] = 1;
        odd[o<<1] = odd[o<<1|1] = odd[o];
        stal[o<<1] = star[o << 1] = odd[o];
        stal[o<<1|1] = star[o<<1|1] = odd[o];
        odd[o] = -1;
    }
}
void update(int l,int r,int o)
{
    if(A <= l && r <= B)
    {
        sum[o] = 1;
        stal[o] = star[o] = C;
        odd[o] = C;
        return;
    }
    int len = r - l + 1;
    down(o,len);
    int mid = (l + r) >> 1;
    if(mid >= A) update(lson);
    if(mid < B) update(rson);
    sum[o] = sum[o << 1] + sum[o<<1|1];
    star[o] = star[o<<1|1];
    stal[o] = stal[o<<1];
    if(star[o << 1] == stal[o<<1|1])
        sum[o]--;
}
int qurry(int l,int r,int o)
{
    if(A <= l && r <=B)
    {
        return sum[o];
    }
    int len = r - l + 1;
    down(o,len);
    int mid = (l + r) >> 1;
    int ans = 0;
    if(A <= mid && B > mid)
    {
        ans += qurry(lson);
        ans += qurry(rson);
        if(star[o<<1] == stal[o<<1|1])
            ans--;
    }
    else if(A <= mid)
        ans = qurry(lson);
    else if(B > mid)
        ans = qurry(rson);
    return ans;
}
//更新的时候记得用vis取得线段树下标，不要用原来树中的编号。
int next[100005][2],ok[100005];
int qurry1(int l,int r,int o)
{
    if(l == r)
    {
        //printf("now = %d\n",stal[o]);
        return stal[o];
    }
    int len = r - l + 1;
    down(o,len);
    int mid = (l + r) >> 1;
    if(A <= mid) return qurry1(lson);
    else return qurry1(rson);
}
void solve(int a,int b,int c)
{
    int q = top[a],w = top[b];
    int anss = 0;
    next[b][0] = b;
    next[a][0] = a;
    next[b][1] = -1;
    next[b][1] = -1;
    int a1 = a,b1 = b;
    while(q != w)
    {
        if(dep[q] < dep[w])
        {
            swap(q,w);
            swap(a,b);
        }
        A = vis[q] , B = vis[a];
        if(c == 0)
        {
            anss += qurry(1,n,1);
            if(next[a][0] != a)
            {
                A = vis[a];
                int q1 = qurry1(1,n,1);
                A = vis[next[a][0]];
                int w1 = qurry1(1,n,1);
                if(q1 == w1)
                    anss--;
            }
        }
        else
            update(1,n,1);
        //记得更新a跟q顺序不能反
        a = fa[q];
        if(top[a] == w && b == a)
        {
            if(next[a][0] != a)
                next[a][1] = q;
            else
            {
                next[a][0] = q;
                next[a][1] = -1;
            }
        }
        else
        {
            next[a][0] = q;
            next[a][1] = -1;
        }
        ok[a] = 1;
        q = top[a];
    }
    if(dep[a] > dep[b])
    {
        swap(a,b);
    }
    A = vis[a],B = vis[b];
    if(c == 0)
    {
         anss += qurry(1,n,1);
         if(a != b && next[a][0] != a)
         {
             A = vis[a];
             int q1 = qurry1(1,n,1);
             A = vis[next[a][0]];
             int w1 = qurry1(1,n,1);
             if(q1 == w1)
                 anss--;
         }
         if(a == b && next[a][1] != -1)
         {
             A = vis[b];
             int q1 = qurry1(1,n,1);
             A = vis[next[a][1]];
             int w1 = qurry1(1,n,1);
             if(q1 == w1)
                 anss--;
             q = top[a1],w = top[b1];
             int kk = 0;
             while(q != w)
             {
                 if(dep[q] < dep[w])
                 {
                     swap(q,w);
                     swap(a1,b1);
                 }
                 A = vis[q],B = vis[a1];
                 if(vis[next[a][0]] >= A && vis[next[a][0]] <= B)
                 {
                     kk = 1;
                 }
                 a1 = fa[q];
                 q = top[a1];
             }
             if(dep[a1] > dep[b1])
                swap(a1,b1);
             A = vis[a1],B = vis[b1];
             if(vis[next[a][0]] >= A && vis[next[a][0]] <= B)
                kk = 1;
             if(kk)
             {
                A = vis[a];
                int q1 = qurry1(1,n,1);
                A = vis[next[a][0]];
                int w1 = qurry1(1,n,1);
                if(q1 == w1)
                   anss--;
             }
         }
         if(a == b && next[a][1] == -1 && next[a][0] != a)
         {
             A = vis[a];
             int q1 = qurry1(1,n,1);
             A = vis[next[a][0]];
             int w1 = qurry1(1,n,1);
             if(q1 == w1)
                 anss--;
         }
         if(a != b && next[b][0] != b)
         {
             A = vis[b];
             int q1 = qurry1(1,n,1);
             A = vis[next[b][0]];
             int w1 = qurry1(1,n,1);
             if(q1 == w1)
                 anss--;
         }
         printf("%d\n",anss);
    }
    else
    {
        update(1,n,1);
        A = vis[a];
        int q1 = qurry1(1,n,1);
        A = vis[b];
        int w1 = qurry1(1,n,1);
        //printf("--%d --%d\n",q1,w1);
    }
}
int node[maxn];
int main()
{
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        init();
        memset(sum,0,sizeof(sum));
        memset(odd,-1,sizeof(odd));
        int i,j,a1,b1;
        for(i = 0; i < n; i++)
        {
            scanf("%d",&node[i]);
        }
        for(i = 1; i < n; i++)
        {
            scanf("%d %d",&a1,&b1);
            add(a1,b1);
            add(b1,a1);
        }
        dfs1(1,1,1);
        dfs2(1,1);
        for(i = 0; i < n; i++)
        {
            A = vis[i+1];C = node[i];
            B = A;
            update(1,n,1);
        }
        char str[3];
        while(m--)
        {
            int c1 = 0;
            scanf("%s %d %d",str,&a1,&b1);
            if(str[0] == 'C')
            {
                c1 = 1;
                scanf("%d",&C);
            }
            solve(a1,b1,c1);
        }
    }
    return 0;
}