（树链剖分+区间合并）HYSBZ - 2243 染色

题意：

两个操作：

1、把一条树链上的所有点权值变为w。

2、查询一条树链上有多少个颜色段

 

分析：

一看就是区间合并，做这到题首先需要一定的区间合并基础，

不过这题合并这部分在线段树区间合并中已经算是非常的简单的了。

线段树部分没有难度。

那么难点在于，在往LCA上走的时候，我们如何进行区间合并。

本来我想着， 在向上走的时候顺便进行区间判断并且合并，但是似乎有问题。

其实，可以将两步分开，先算出区间没合并之前的颜色段数，再次进行Top，判断颜色是否相等，相等就减掉。

 

代码：

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;

const int maxn = 1000000;
const int inf = 0x3f3f3f3f;

struct Edge {
    int to, next;
} edge[maxn << 1];

int head[maxn], tot;
int top[maxn];
int fa[maxn];
int deep[maxn];
int num[maxn];
int p[maxn];
int fp[maxn];
int son[maxn];
int pos;

int val[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) {
    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) {
    top[u] = sp;
    p[u] = pos++;
    fp[p[u]] = u;
    if (son[u] == -1) return;
    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);
    }
}

struct Node {
    int left, right;
    int cnt, lcol, rcol;
    int lazy;
} node[maxn << 2];

void build(int n, int left, int right) {
    node[n].left = left;
    node[n].right = right;
    node[n].cnt = node[n].lcol = node[n].rcol = 0;
    node[n].lazy = -1;
    if (left == right) return;
    int mid = (left + right) >> 1;
    build(n << 1, left, mid);
    build(n << 1 | 1, mid + 1, right);
}

void push_up(int n) {
    node[n].lcol = node[n << 1].lcol;
    node[n].rcol = node[n << 1 | 1].rcol;
    node[n].cnt = node[n << 1].cnt + node[n << 1 | 1].cnt;
    if (node[n << 1].rcol == node[n << 1 | 1].lcol) node[n].cnt--;
}

void push_down(int n) {
    if (node[n].lazy != -1) {
        node[n << 1].cnt = 1;
        node[n << 1].lcol = node[n << 1].rcol = node[n].lazy;
        node[n << 1].lazy = node[n].lazy;
        node[n << 1 | 1].cnt = 1;
        node[n << 1 | 1].lcol = node[n << 1 | 1].rcol = node[n].lazy;
        node[n << 1 | 1].lazy = node[n].lazy;
        node[n].lazy = -1;
    }
}

void update(int n, int left, int right, int val) {
    if (left <= node[n].left && node[n].right <= right) {
        node[n].cnt = 1;
        node[n].lcol = node[n].rcol = val;
        node[n].lazy = val;
        return;
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    if (mid >= left) update(n << 1, left, right, val);
    if (mid < right) update(n << 1 | 1, left, right, val);
    push_up(n);
}

int query_cnt(int n, int left, int right) {
    if (left <= node[n].left && node[n].right <= right) {
        return node[n].cnt;
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    if (mid >= right)
        return query_cnt(n << 1, left, right);
    else if (mid < left)
        return query_cnt(n << 1 | 1, left, right);
    else {
        int lcnt = query_cnt(n << 1, left, right);
        int rcnt = query_cnt(n << 1 | 1, left, right);
        int cnt = lcnt + rcnt;
        if (node[n << 1].rcol == node[n << 1 | 1].lcol) cnt--;
        push_up(n);
        return cnt;
    }
}

int query_col(int n, int pos) {
    if (node[n].left == node[n].right) {
        return node[n].lcol;
    }
    push_down(n);
    int mid = (node[n].left + node[n].right) >> 1;
    if (pos <= mid)
        return query_col(n << 1, pos);
    else
        return query_col(n << 1 | 1, pos);
}

int findCnt(int x, int y) {
    int u = x, v = y;
    int tmp = 0;
    int precol = -1;
    while (top[x] != top[y]) {
        if (deep[top[x]] < deep[top[y]]) swap(x, y);
        tmp += query_cnt(1, p[top[x]], p[x]);
        x = fa[top[x]];
    }
    if (deep[x] > deep[y]) swap(x, y);
    tmp += query_cnt(1, p[x], p[y]);
    // if (top[u] == top[v]) return tmp;
    while (top[u] != top[x]) {
        int col1 = query_col(1, p[top[u]]);
        int col2 = query_col(1, p[fa[top[u]]]);
        if (col1 == col2) tmp--;
        u = fa[top[u]];
    }
    while (top[v] != top[x]) {
        int col1 = query_col(1, p[top[v]]);
        int col2 = query_col(1, p[fa[top[v]]]);
        if (col1 == col2) tmp--;
        v = fa[top[v]];
    }
    return tmp;
}

void Change(int x, int y, int val) {
    while (top[x] != top[y]) {
        if (deep[top[x]] < deep[top[y]]) swap(x, y);
        update(1, p[top[x]], p[x], val);
        x = fa[top[x]];
    }
    if (deep[x] > deep[y]) swap(x, y);
    update(1, p[x], p[y], val);
}

int main() {
    int t;
    int n;
    int q;
    while (~scanf("%d%d", &n, &q)) {
        init();
        for (int i = 1; i <= n; i++) {
            scanf("%d", &val[i]);
        }
        for (int i = 0; i < n - 1; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            addedge(u, v);
            addedge(v, u);
        }

        dfs1(1, 0, 0);
        getpos(1, 1);
        build(1, 0, pos - 1);
        for (int i = 1; i <= n; i++) {
            update(1, p[i], p[i], val[i]);
        }
        scanf("%d", &q);
        char op[10];
        int u, v;
        while (q--) {
            scanf("%s%d%d", op, &u, &v);
            if (op[0] == 'Q') {
                printf("%d\n", findCnt(u, v));
            } else {
                int val;
                scanf("%d", &val);
                Change(u, v, val);
            }
        }
    }
    return 0;
}