BZOJ 2243 SDOI 2011染色

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=2243

算法讨论：

树链剖分把树放到线段树上。然后线段树的每个节点要维护的东西有左端点的颜色，右端点的颜色，以及是否被改变过颜色，和颜色段数。

向上合并的过程中，要注意如果左孩子的右端点和右孩子的左端点颜色相同，那么就要把颜色段数减一。

然后我们考虑询问的问题：

对于一个询问，我们是按深度从下向上跳着计算的，所以每次统计一个路径的时候，我们要记录上一次的路径的两端点的颜色，如果本次路径计算的

右端点颜色和上次的左端点颜色相同，那么答案就要减去1.（注意树链剖分，如果在同一次线段树内查询，那么节点深度小的一定线段树的编号也小）。

当两个节点跳到一个重链上的时候，那么此时两边的颜色都要进行判断一下。至于为啥，很好想吧。

题目代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>

using namespace std;
const int N = 100000 + 5;
inline int read() {
  int x = 0;
  char c = getchar();
  while(!isdigit(c)) c = getchar();
  while(isdigit(c)) {
    x = x * 10 + c - '0';
    c = getchar();
  }
  return x;
}

struct SegmentTree {
  int lc, rc, l, r, tag, sz;
}Node[N * 4];
struct Edge {
  int from, to, next;
}edges[N << 1];

char ss[3];
int n, m, cnt, pos, co[N], lco, rco;
int fa[N], head[N], son[N], size[N];
int num[N], top[N], depth[N], seg[N];

void insert(int from, int to) {
  ++ cnt;
  edges[cnt].from = from; edges[cnt].to = to;
  edges[cnt].next = head[from]; head[from] = cnt;
}

void dfs_1(int u, int f) {
  fa[u] = f; size[u] = 1;
  for(int i = head[u]; i; i = edges[i].next) {
    int v = edges[i].to;
    if(v != f) {
      depth[v] = depth[u] + 1;
      dfs_1(v, u);
      size[u] += size[v];
      if(!son[u] || size[v] > size[son[u]])
        son[u] = v;
    }
  }
}

void dfs_2(int u, int ances) {
  top[u] = ances;
  num[u] = ++ pos;
  seg[pos] = u;
  if(!son[u]) return;
  dfs_2(son[u], ances);
  for(int i = head[u]; i; i = edges[i].next) {
    int v = edges[i].to;
    if(v != fa[u] && v != son[u]) {
      dfs_2(v, v);
    }
  }
}

void pushdown(int o) {
  if(Node[o].l == Node[o].r) return;
  int l = o << 1, r = o << 1 | 1;
  if(Node[o].tag) {
    Node[l].tag = Node[r].tag = Node[o].tag;
    Node[l].lc = Node[l].rc = Node[o].tag;
    Node[r].lc = Node[r].rc = Node[o].tag;
    Node[l].sz = Node[r].sz = 1;
    Node[o].tag = 0;
  }
}

void pushup(int o) {
  if(Node[o].l == Node[o].r) return;
  int l = o << 1, r = o << 1 | 1;
  Node[o].lc = Node[l].lc;
  Node[o].rc = Node[r].rc;
  Node[o].sz = Node[l].sz + Node[r].sz - (Node[l].rc == Node[r].lc);
}

void build(int o, int l, int r) {
  Node[o].l = l; Node[o].r = r; Node[o].tag = 0;
  if(l == r) {
    Node[o].sz = 1;
    Node[o].lc = Node[o].rc = co[seg[l]];
    return;
  }
  int mid = (l + r) >> 1;
  build(o << 1, l, mid); build(o << 1 | 1, mid + 1, r);
  pushup(o);
}

void update(int o, int l, int r, int v) {
  if(Node[o].l == l && Node[o].r == r) {
    Node[o].lc = Node[o].rc = v;
    Node[o].tag = v; Node[o].sz = 1;
    return;
  }
  int mid = (Node[o].l + Node[o].r) >> 1;
  pushdown(o);
  if(r <= mid) update(o << 1, l, r, v);
  else if(l > mid) update(o << 1 | 1, l, r, v);
  else {
    update(o << 1, l, mid, v);
    update(o << 1 | 1, mid + 1, r, v);
  }
  pushup(o);
}

int query(int o, int l, int r, int L, int R) {
  if(Node[o].l == L) lco = Node[o].lc;
  if(Node[o].r == R) rco = Node[o].rc;
  if(Node[o].l == l && Node[o].r == r) {
    return Node[o].sz;
  }
  int mid = (Node[o].l + Node[o].r) >> 1;
  pushdown(o);
  if(r <= mid) return query(o << 1, l, r, L, R);
  else if(l > mid) return query(o << 1 | 1, l, r, L, R);
  else {
    return query(o << 1, l, mid, L, R) + query(o << 1 | 1, mid + 1, r, L, R) - (Node[o << 1].rc == Node[o << 1 | 1].lc);
  }
  pushup(o);
}

void Update(int x, int y, int z) {
  int f1 = top[x], f2 = top[y];
  while(f1 != f2) {
    if(depth[f1] < depth[f2]) {
      swap(x, y); swap(f1, f2);
    }
    update(1, num[f1], num[x], z);
    x = fa[f1]; f1 = top[x];
  }
  if(depth[x] < depth[y]) {
    update(1, num[x], num[y], z);
  }
  else {
    update(1, num[y], num[x], z);
  }
}

int Query(int x, int y) {
  int f1 = top[x], f2 = top[y], res = 0;
  int ans1 = -1, ans2 = -1;
  while(f1 != f2) {
    if(depth[f1] < depth[f2]) {
      swap(f1, f2); swap(x, y);
      swap(ans1, ans2);
    }
    res += query(1, num[f1], num[x], num[f1], num[x]);
    if(rco == ans1) res --; ans1 = lco;
    x = fa[f1]; f1 = top[x];
  }
  if(depth[x] < depth[y]) {
    swap(x, y); swap(ans1, ans2);
  }
  res += query(1, num[y], num[x], num[y], num[x]);
  if(rco == ans1) res --;
  if(lco == ans2) res --;
  return res;
}

int main() {
  int x, y, z;
  n = read(); m = read();
  for(int i = 1; i <= n; ++ i) co[i] = read();
  for(int i = 1; i < n; ++ i) {
    x = read(); y = read();
    insert(x, y); insert(y, x);
  }
  depth[1] = 1;
  dfs_1(1, -1); dfs_2(1, 1);
  build(1, 1, n);
  for(int i = 1; i <= m; ++ i) {
    scanf("%s", ss);
    if(ss[0] == 'C') {
      x = read(); y = read(); z = read();
      Update(x, y, z);
    }
    else {
      x = read(); y = read();
      printf("%d\n", Query(x, y));
    }
  }
  return 0;
}