[Luogu] 染色

https://www.luogu.org/problemnew/show/P2486

qizha

为什么会wa

#include <cstdio>
#include <cmath>
#include <iostream>
#include <cstring>
 
using std:: cin;
using std:: cout;
using std:: endl;
using std:: swap;
using std:: string;
 
#define gc getchar()
 
const int N = 1e5 + ;
 
//...数据
int n, m, data[N];
//...图
int now = , head[N];
struct Node {int u, v, nxt;} G[N << ];
//...树剖
int tim;
int fa[N], deep[N], size[N], topp[N], son[N], tree[N], bef[N];
//...线段树
int L[N << ], R[N << ], F[N << ], l_col[N << ], r_col[N << ], tot[N << ];
//...查询操作
int Lc, Rc, ans; 
 
inline int read() {
    int x = , f = ; char c = gc;
    while(c < '' || c > '') {if(c == '-') f = -; c = gc;}
    while(c >= '' && c <= '') x = x *  + c - '', c = gc;
    return x * f;
}
 
inline void Add(int u, int v) {G[now].v = v; G[now].nxt = head[u]; head[u] = now ++;}
 
void Dfs_find_son(int u, int f_, int dep) {
    fa[u] = f_;
    deep[u] = dep;
    size[u] = ;
    for(int i = head[u]; ~ i; i = G[i].nxt) {
        int v = G[i].v;
        if(v != f_) {
            Dfs_find_son(v, u, dep + );
            size[u] += size[v];
            if(size[v] > size[son[u]]) son[u] = v;
        }
    }
}
 
void Dfs_to_un(int u, int tp) {
    topp[u] = tp;
    tree[u] = ++ tim;
    bef[tim] = u;
    if(! son[u]) return ;
    Dfs_to_un(son[u], tp);
    for(int i = head[u]; ~ i; i = G[i].nxt) {
        int v = G[i].v;
        if(v != fa[u] && v != son[u]) Dfs_to_un(v, v);
    }
}
 
#define lson jd << 1
#define rson jd << 1 | 1
 
void Up(int jd) {
    l_col[jd] = l_col[lson]; r_col[jd] = r_col[rson];
    tot[jd] = tot[lson] + tot[rson];
    if(r_col[lson] == l_col[rson]) tot[jd] --;
}
 
void Build_tree(int l, int r, int jd) {
    L[jd] = l; R[jd] = r; F[jd] = -;
    if(l == r) {
        l_col[jd] = r_col[jd] = data[bef[l]];
        tot[jd] = ;
        return ;
    }
    int mid = (l + r) >> ;
    Build_tree(l, mid, lson);
    Build_tree(mid + , r, rson);
    Up(jd);
}
 
void Down_f(int jd) {
    F[lson] = F[rson] = F[jd];
    tot[lson] = tot[rson] = ;
    l_col[lson] = r_col[lson] = l_col[rson] = r_col[rson] = F[jd];
    F[jd] = -;
    return ;
}
 
void Sec_A(int l, int r, int jd, int x, int y) {
    if(x == L[jd]) Lc = l_col[jd];
    if(y == R[jd]) Rc = r_col[jd];
    if(x <= l && r <= y) {ans += tot[jd]; return ;}
    if(F[jd] != -) Down_f(jd);
    int mid = (l + r) >> ;
    if(x <= mid) Sec_A(l, mid, lson, x, y);
    if(y > mid)  Sec_A(mid + , r, rson, x, y);
    if(x <= mid && y > mid && r_col[lson] == l_col[rson]) ans --;
}
 
inline int Sec_A_imp(int x, int y) {
    int tp1 = topp[x], tp2 = topp[y], ret = , prex = -, prey = -;
    while(tp1 != tp2) {
        if(deep[tp1] < deep[tp2]) swap(tp1, tp2), swap(prex, prey), swap(x, y);
        ans = ;
        Sec_A(, n, , tree[tp1], tree[x]);
        ret += ans;
        if(Rc == prex) ret --;
        prex = Lc;
        x = fa[tp1];
        tp1 = topp[x];
    }
    if(deep[x] < deep[y]) swap(x, y), swap(prex, prey);
    ans = ;
    Sec_A(, n, , tree[y], tree[x]);
    ret += ans;
    if(Lc == prey) ret --;
    if(Rc == prex) ret --;
    return ret;
}
 
void Sec_G(int l, int r, int jd, int x, int y, int how) {
    if(x <= l && r <= y) {
        F[jd] = how; tot[jd] = ; l_col[jd] = r_col[jd] = how;
        return ;
    }
    int mid = (l + r) >> ;
    if(x <= mid) Sec_G(l, mid, lson, x, y, how);
    if(y > mid)  Sec_G(mid + , r, rson, x, y, how);
    Up(jd);
}
 
void Sec_G_imp(int x, int y, int how) {
    int tp1 = topp[x], tp2 = topp[y];
    while(tp1 != tp2) {
        if(deep[tp1] < deep[tp2]) swap(tp1, tp2), swap(x, y);
        Sec_G(, n, , tree[tp1], tree[x], how);
        x = fa[tp1];
        tp1 = topp[x];
    }
    if(deep[x] < deep[y]) swap(x, y);
    Sec_G(, n, , tree[y], tree[x], how);
    return ;
}
 
#define RR freopen("gg.in", "r", stdin)
 
int main() {
    //RR;
    n = read(); m = read();
    for(int i = ; i <= n; i ++) data[i] = read();
    for(int i = ; i <= n; i ++) head[i] = -;
    for(int i = ; i <  n; i ++) {
        int u = read(), v = read();
        Add(u, v); Add(v, u);
    }
    Dfs_find_son(, , );
    Dfs_to_un(, );
    Build_tree(, n, );
    while(m --) {
        string s;
        cin >> s;
        if(s[] == 'Q') {
            int x = read(), y = read();
            cout << Sec_A_imp(x, y) << endl;
        } else {
            int x = read(), y = read(), how = read();
            Sec_G_imp(x, y, how);
        }
    }
    return ;
}
/*
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
*/