【SDOI2011 第1轮 DAY1】染色

题目

问题描述

给定一棵有个节点的无根树和m个操作，操作有2类：
1、将节点a到节点b路径上所有点都染成颜色c；
2、询问节点a到节点b路径上的颜色段数量（连续相同颜色被认为是同一段），如“112221”由3段组成：“11”、“222”和“1”。
请你写一个程序依次完成这m个操作。

输入格式

第一行包含2个整数n和m，分别表示节点数和操作数；
第二行包含n个正整数表示n个节点的初始颜色
下面n-1行每行包含两个整数x和y，表示x和y之间有一条无向边。
下面m行每行描述一个操作：
“C a b c”表示这是一个染色操作，把节点a到节点b路径上所有点（包括a和b）都染成颜色；
“Q a b”表示这是一个询问操作，询问节点a到节点b（包括a和b）路径上的颜色段数量。

输出格式

对于每个询问操作，输出一行答案。

样例输入

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

样例输出

3
1
2

提示

【数据规模和约定】





【友情提示】
　　不允许使用编译开关改变栈空间大小，请选手尽量不要使用递归，以避免堆栈溢出。

友情提示无用，请略过

题解&&思路

这道题是一道树链剖分加线段树板题，但是有很多细节。

线段树记下sum段数，numl从左到右第一个连续一段的颜色，numr从左到右第一个连续一段的颜色，lazy标记

首先lazy标记初值最好为-1，因为c可以为0，然后lazy需下传

接着合并时一定要搞清楚左边与右边是哪一边，合并时应该怎样合并

然后就没什么了

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 1e5 + 4;
int n, m, siz[MAXN], hei[MAXN], fa[MAXN], top[MAXN], zson[MAXN], id[MAXN], ncnt;
int a[MAXN], fd[MAXN];
vector<int> G[MAXN];
struct node {
    int l, r;
    ll lazy, sum, numl, numr;
} tre[MAXN << 2];
inline node hb(node x, node y) {
    node ans;
    ans.sum = (x.sum + y.sum);
    ans.numl = x.numl, ans.numr = y.numr;
    if (x.numr == y.numl)
        ans.sum--;
    return ans;
}
void dfs(int x, int f) {
    siz[x] = 1;
    int maxx = 0, tot = 0;
    for (int i = 0; i < G[x].size(); i++) {
        int v = G[x][i];
        if (v == f)
            continue;
        hei[v] = hei[x] + 1;
        fa[v] = x;
        dfs(v, x);
        siz[x] += siz[v];
        if (siz[v] > maxx)
            maxx = siz[v], tot = v;
    }
    zson[x] = tot;
}
void dfs1(int x, int f) {
    top[x] = f;
    id[x] = ++ncnt;
    fd[ncnt] = x;
    if (!zson[x])
        return;
    dfs1(zson[x], f);
    for (int i = 0; i < G[x].size(); i++) {
        int v = G[x][i];
        if (v != fa[x] && v != zson[x])
            dfs1(v, v);
    }
}
inline void pushup(int i) {
    tre[i].sum = tre[i << 1].sum + tre[i << 1 | 1].sum;
    tre[i].numl = tre[i << 1].numl, tre[i].numr = tre[i << 1 | 1].numr;
    if (tre[i << 1].numr == tre[i << 1 | 1].numl)
        tre[i].sum--;
}
inline void build(int i, int l, int r) {
    tre[i].l = l, tre[i].r = r;
    tre[i].sum = 0, tre[i].lazy = -1;
    if (l == r) {
        tre[i].numl = tre[i].numr = a[fd[l]];
        tre[i].sum = 1;
        return;
    }
    int mid = (l + r) >> 1;
    build(i << 1, l, mid);
    build(i << 1 | 1, mid + 1, r);
    pushup(i);
}
inline void pushdown(int i) {
    if (tre[i].lazy != -1) {
        tre[i << 1].numl = tre[i << 1].numr = tre[i].lazy;
        tre[i << 1 | 1].numl = tre[i << 1 | 1].numr = tre[i].lazy;
        tre[i << 1].sum = tre[i << 1 | 1].sum = 1;
        tre[i << 1].lazy = tre[i << 1 | 1].lazy = tre[i].lazy;
        tre[i].lazy = -1;
    }
}
inline void modify(int i, int l, int r, int delta) {
    if (l > tre[i].r || r < tre[i].l)
        return;
    if (tre[i].l >= l && tre[i].r <= r) {
        tre[i].sum = 1;
        tre[i].lazy = delta;
        tre[i].numl = tre[i].numr = delta;
        return;
    }
    pushdown(i);
    modify(i << 1, l, r, delta);
    modify(i << 1 | 1, l, r, delta);
    pushup(i);
}
inline void query(int i, int l, int r, node &ans) {
    if (l > tre[i].r || r < tre[i].l)
        return;
    if (tre[i].l >= l && tre[i].r <= r) {
        if (ans.sum == 0)
            ans = tre[i];
        else
            ans = hb(ans, tre[i]);
        return;
    }
    pushdown(i);
    query(i << 1, l, r, ans);
    query(i << 1 | 1, l, r, ans);
    pushup(i);
}
inline void change(int x, int y, int z) {
    while (top[x] != top[y]) {
        if (hei[top[x]] < hei[top[y]])
            swap(x, y);
        modify(1, id[top[x]], id[x], z);
        x = fa[top[x]];
    }
    if (hei[x] > hei[y])
        swap(x, y);
    modify(1, id[x], id[y], z);
}
inline void get_ans(int x, int y) {
    node ansx, ansy;
    ansx.sum = ansy.sum = 0;
    while (top[x] != top[y]) {
        if (hei[top[x]] < hei[top[y]]) {
            node tot;
            tot.sum = 0;
            query(1, id[top[y]], id[y], tot);
            if (ansy.sum == 0)
                ansy = tot;
            else
                ansy = hb(tot, ansy);
            y = fa[top[y]];
        } else {
            node tot;
            tot.sum = 0;
            query(1, id[top[x]], id[x], tot);
            if (ansx.sum == 0)
                ansx = tot;
            else
                ansx = hb(tot, ansx);
            x = fa[top[x]];
        }
    }
    if (hei[x] > hei[y]) {
        node tot;
        tot.sum = 0;
        query(1, id[y], id[x], tot);
        if (ansx.sum == 0)
            ansx = tot;
        else
            ansx = hb(tot, ansx);
        if (ansy.sum == 0)
            ansy = ansx;
        else {
            swap(ansy.numl, ansy.numr);
            ansy = hb(ansy, ansx);
        }
        printf("%lld\n", ansy.sum);
    } else {
        node tot;
        tot.sum = 0;
        query(1, id[x], id[y], tot);
        if (ansy.sum == 0)
            ansy = tot;
        else
            ansy = hb(tot, ansy);
        if (ansx.sum == 0)
            ansx = ansy;
        else {
            swap(ansx.numl, ansx.numr);
            ansx = hb(ansx, ansy);
        }
        printf("%lld\n", ansx.sum);
    }
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i < n; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        G[x].push_back(y);
        G[y].push_back(x);
    }
    hei[1] = 1;
    dfs(1, 1);
    dfs1(1, 1);
    build(1, 1, n);
    while (m--) {
        char u;
        int x, y;
        cin >> u;
        cin >> x >> y;
        if (u == 'C') {
            int z;
            cin >> z;
            change(x, y, z);
        } else {
            get_ans(x, y);
        }
    }
    return 0;
}