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 =  + ;
 inline int read() {
   int x = ;
   char c = getchar();
   while(!isdigit(c)) c = getchar();
   while(isdigit(c)) {
     x = x *  + c - '';
     c = getchar();
   }
   return x;
 }

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

 char ss[];
 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] = ;
   for(int i = head[u]; i; i = edges[i].next) {
     int v = edges[i].to;
     if(v != f) {
       depth[v] = depth[u] + ;
       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 << , r = o <<  | ;
   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 = ;
     Node[o].tag = ;
   }
 }

 void pushup(int o) {
   if(Node[o].l == Node[o].r) return;
   int l = o << , r = o <<  | ;
   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 = ;
   if(l == r) {
     Node[o].sz = ;
     Node[o].lc = Node[o].rc = co[seg[l]];
     return;
   }
   int mid = (l + r) >> ;
   build(o << , l, mid); build(o <<  | , mid + , 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 = ;
     return;
   }
   int mid = (Node[o].l + Node[o].r) >> ;
   pushdown(o);
   if(r <= mid) update(o << , l, r, v);
   else if(l > mid) update(o <<  | , l, r, v);
   else {
     update(o << , l, mid, v);
     update(o <<  | , mid + , 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) >> ;
   pushdown(o);
   if(r <= mid) return query(o << , l, r, L, R);
   else if(l > mid) return query(o <<  | , l, r, L, R);
   else {
     return query(o << , l, mid, L, R) + query(o <<  | , mid + , r, L, R) - (Node[o << ].rc == Node[o <<  | ].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(, num[f1], num[x], z);
     x = fa[f1]; f1 = top[x];
   }
   if(depth[x] < depth[y]) {
     update(, num[x], num[y], z);
   }
   else {
     update(, num[y], num[x], z);
   }
 }

 int Query(int x, int y) {
   int f1 = top[x], f2 = top[y], res = ;
   int ans1 = -, ans2 = -;
   while(f1 != f2) {
     if(depth[f1] < depth[f2]) {
       swap(f1, f2); swap(x, y);
       swap(ans1, ans2);
     }
     res += query(, 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(, 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 = ; i <= n; ++ i) co[i] = read();
   for(int i = ; i < n; ++ i) {
     x = read(); y = read();
     insert(x, y); insert(y, x);
   }
   depth[] = ;
   dfs_1(, -); dfs_2(, );
   build(, , n);
   for(int i = ; i <= m; ++ i) {
     scanf("%s", ss);
     if(ss[] == 'C') {
       x = read(); y = read(); z = read();
       Update(x, y, z);
     }
     else {
       x = read(); y = read();
       printf("%d\n", Query(x, y));
     }
   }
   return ;
 }

BZOJ2243