BZOJ2243 [SDOI2011]染色

恩恩树链剖分一下

于是用线段树维护每一个子段的颜色信息 --不同颜色段数，因为要合并所以还要维护每一段的左右端点颜色信息

然后就没有然后了2333

尝试着写了个指针版的。。。感觉还可以啊

（话说，是不是写多棵线段树会快啊？）

 

/**************************************************************
    Problem: 2243
    User: rausen
    Language: C++
    Result: Accepted
    Time:4176 ms
    Memory:31324 kb
****************************************************************/
 
#include <cstdio>
#include <algorithm>
 
using namespace std;
const int N = 100005;
const int M = N << 2;
const int Maxlen = N * 75;
 
char buf[Maxlen], *C = buf;
int Len;
 
struct edge {
    int next, to;
    edge() {}
    edge(int _n, int _t) : next(_n), to(_t) {}
} e[N << 1];
 
int first[N], tot;
 
struct tree_node {
    int sz, dep, fa, son, top, w;
} tr[N];
 
int cnt_tree;
 
struct seg_node {
    seg_node *lson, *rson;
    int l, r, sz, tag, lc, rc;
     
    inline void fill(int _s, int _t) {
        sz = _s;
        tag = _t, lc = _t, rc = _t;
    }
} *root, mempool[M], *cnt_seg = mempool;
 
int n, Q, c[N];
 
inline int read() {
    int x = 0;
    while (*C < '0' || '9' < *C) ++C;
    while ('0' <= *C && *C <= '9')
        x = x * 10 + *C - '0', ++C;
    return x;
}
 
inline void Add_Edges(int x, int y) {
    e[++tot] = edge(first[x], y), first[x] = tot;
    e[++tot] = edge(first[y], x), first[y] = tot;
}
 
 
void dfs(int p) {
    int x, y;
    tr[p].sz = 1;
    for (x = first[p]; x; x = e[x].next)
        if ((y = e[x].to) != tr[p].fa) {
            tr[y].dep = tr[p].dep + 1, tr[y].fa = p;
            dfs(y);
            tr[p].sz += tr[y].sz;
            if (!tr[p].son || tr[tr[p].son].sz < tr[y].sz)
                tr[p].son = y;
        }
}
 
void DFS(int p) {
    tr[p].w = ++cnt_tree;
    if (!tr[p].son) return;
    tr[tr[p].son].top = tr[p].top;
    DFS(tr[p].son);
    int x, y;
    for (x = first[p]; x; x = e[x].next)
        if ((y = e[x].to) != tr[p].fa && y != tr[p].son) {
            tr[y].top = y;
            DFS(y);
        }
}
 
 
#define L p -> l
#define R p -> r
#define Lc p -> lc
#define Rc p -> rc
#define Sz p -> sz
#define Tag p -> tag
#define Lson p -> lson
#define Rson p -> rson
#define mid (l + r >> 1)
void seg_build(seg_node *&p, int l, int r) {
    p = ++cnt_seg;
    L = l, R = r, Sz = 1, Tag = -1;
    if (l == r) return;
    seg_build(Lson, l, mid), seg_build(Rson, mid + 1, r);
}
#undef mid
 
inline void seg_push_up(seg_node *p) {
    Lc = Lson -> lc, Rc = Rson -> rc;
    Sz = Lson -> sz + Rson -> sz;
    if (Lson -> rc == Rson -> lc) Sz -= 1;
}
 
inline void seg_push_down(seg_node *p) {
    if (Tag == -1 || L == R) {
        Tag = -1;
        return;
    }
    (*Lson).fill(1, Tag);
    (*Rson).fill(1, Tag);
    Tag = -1;
}
 
#define mid (L + R >> 1)
void seg_update(seg_node *p, int l, int r, int c) {
    seg_push_down(p);
    if (l == L && R == r) {
        (*p).fill(1, c);
        return;
    }
    if (r <= mid) seg_update(Lson, l, r, c);
    else if (mid < l) seg_update(Rson, l, r, c);
    else {
        seg_update(Lson, l, mid, c);
        seg_update(Rson, mid + 1, r, c);
    }
    seg_push_up(p);
}
 
int seg_query_cnt(seg_node *p, int l, int r) {
    seg_push_down(p);
    if (l == L && R == r) return Sz;
    if (r <= mid) return seg_query_cnt(Lson, l, r);
    else if (mid < l) return seg_query_cnt(Rson, l, r);
    else {
        return seg_query_cnt(Lson, l, mid) + seg_query_cnt(Rson, mid + 1, r) -
            (Lson -> rc == Rson -> lc);
    }
}
 
int seg_query_color(seg_node *p, int pos) {
    seg_push_down(p);
    if (L == R) return Lc;
    if (pos <= mid) return seg_query_color(Lson, pos);
    else return seg_query_color(Rson, pos);
}
#undef mid
 
 
void work_change(int x, int y, int c) {
    while (tr[x].top != tr[y].top) {
        if (tr[tr[x].top].dep < tr[tr[y].top].dep)
            swap(x, y);
        seg_update(root, tr[tr[x].top].w, tr[x].w, c);
        x = tr[tr[x].top].fa;
    }
    if (tr[x].dep < tr[y].dep)
        swap(x, y);
    seg_update(root, tr[y].w, tr[x].w, c);
}
 
int work_sum(int x, int y) {
    int res = 0;
    while (tr[x].top != tr[y].top) {
        if (tr[tr[x].top].dep < tr[tr[y].top].dep)
            swap(x, y);
        res += seg_query_cnt(root, tr[tr[x].top].w, tr[x].w);
        x = tr[x].top;
        if (seg_query_color(root, tr[x].w) == seg_query_color(root, tr[tr[x].fa].w))
            --res;
        x = tr[x].fa;
    }
    if (tr[x].dep < tr[y].dep)
        swap(x, y);
    res += seg_query_cnt(root, tr[y].w, tr[x].w);
    return res;
}
 
inline void work() {
    int x, y, z;
    while (*C != 'C' && *C != 'Q') ++C;
    if (*C == 'Q') {
        x = read(), y = read();
        printf("%d\n", work_sum(x, y));
    } else {
        x = read(), y = read(), z = read();
        work_change(x, y, z);
    }
}
 
void build() {
    int i;
    for (i = 1; i <= n; ++i)
        c[i] = read();
    for (i = 1; i < n; ++i)
        Add_Edges(read(), read());
    tr[1].fa = -1;
    dfs(1);
    DFS(1);
    seg_build(root, 1, n);
    for (i = 1; i <= n; ++i)
        seg_update(root, tr[i].w, tr[i].w, c[i]);
}
 
int main() {
    Len = fread(C , 1, Maxlen, stdin);
    buf[Len] = '\0';
    n = read(), Q = read();
    build();
    while (Q--) 
        work();
    return 0;
}