[SDOI2011]染色

嘟嘟嘟

一看就知道是一道树剖题。

先树剖转换成线性，然后线段树维护。

维护的时候跟酒店那道题有点像，但比那个简单多了。

首先一个sum代表颜色段数量，然后除了lazy之外还有lco,rco分别代表区间左右端点是啥颜色。

合并的时候除了sum[now] = sum[now <<1] + sum[now << 1 |1]外，还要考虑左右子区间靠在一起的地方颜色是否相等，即rco[now << 1] == lco[now << 1 | 1]，是的话就要减一。

查询的时候需要注意链的顶端的父亲结点和链的顶端结点颜色是否相同，是的话答案还是要--。这个单独写一个线段树单点查询的函数就行，很短。

p.s.emacs的格式就是丑，凑合着看吧

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<cctype>
#include<stack>
#include<queue>
#include<vector>
using namespace std;
#define enter puts("")
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e5 + 5;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), las = ' ';
  while(!isdigit(ch)) las = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 3) + (ans << 1) + ch - '0', ch = getchar();
  if(las == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) putchar('-'), x = -x;
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int n, m, a[maxn];
vector<int> v[maxn];

bool vis[maxn];
int dep[maxn], fa[maxn], siz[maxn], son[maxn];
void dfs1(int now)
{
  vis[now] = 1; siz[now] = 1;
  for(int i = 0; i < (int)v[now].size(); ++i)
    {
      if(!vis[v[now][i]])
    {
      dep[v[now][i]] = dep[now] + 1;
      fa[v[now][i]] = now;
      dfs1(v[now][i]);
      siz[now] += siz[v[now][i]];
      if(!son[now] || siz[son[now]] < siz[v[now][i]]) son[now] = v[now][i];
    }
    }
}
int dfsx[maxn], pos[maxn], top[maxn], cnt = 0;
void dfs2(int now)
{
  dfsx[now] = ++cnt; pos[cnt] = now;
  vis[now] = 1;
  if(son[now])
    {
      top[son[now]] = top[now];
      dfs2(son[now]);
    }
  for(int i = 0; i < (int)v[now].size(); ++i)
    {
      if(!vis[v[now][i]] && v[now][i] != son[now])
    {
      top[v[now][i]] = v[now][i];
      dfs2(v[now][i]);
    }
    }
}

struct Tree
{
  int l, r;
  int sum, lco, rco, lzy;
  Tree operator + (const Tree& other)const
  {
    Tree ret;
    ret.l = l; ret.r = other.r;
    ret.lzy = -1;
    ret.sum = sum + other.sum;
    if(rco == other.lco) ret.sum--;
    ret.lco = lco; ret.rco = other.rco;
    return ret;
  }
}t[maxn << 2];

void build(int L, int R, int now)
{
  t[now].l = L; t[now].r = R;
  t[now].lzy = -1;
  if(L == R)
    {
      t[now].sum = 1;
      t[now].lco = t[now].rco = a[pos[L]];
      return;
    }
  int mid = (L + R) >> 1;
  build(L, mid, now << 1);
  build(mid + 1, R, now << 1 | 1);
  t[now] = t[now << 1] + t[now << 1 | 1];
}
void pushdown(int now)
{
  if(t[now].lzy != -1)
    {
      t[now << 1].sum = t[now << 1 | 1].sum = 1;
      t[now << 1].lzy = t[now << 1 | 1].lzy = t[now].lzy;
      t[now << 1].lco = t[now << 1].rco = t[now].lzy;
      t[now << 1 | 1].lco = t[now << 1 | 1].rco = t[now].lzy;
      t[now].lzy = -1;
    }
}
void update(int L, int R, int now, int d)
{
  if(L == t[now].l && R == t[now].r)
    {
      t[now].sum = 1;
      t[now].lco = t[now].rco = d;
      t[now].lzy = d; return;
    }
  pushdown(now);
  int mid = (t[now].l + t[now].r) >> 1;
  if(R <= mid) update(L, R, now << 1, d);
  else if(L > mid) update(L, R, now << 1 | 1, d);
  else update(L, mid, now << 1, d), update(mid + 1, R, now << 1 | 1, d);
  t[now] = t[now << 1] + t[now << 1 | 1];
}
int query(int L, int R, int now)
{
  if(L == t[now].l && R == t[now].r) return t[now].sum;
  pushdown(now);
  int mid = (t[now].l + t[now].r) >> 1;
  if(R <= mid) return query(L, R, now << 1);
  else if(L > mid) return query(L, R, now << 1 | 1);
  else
    {
      int ret = query(L, mid, now << 1) + query(mid + 1, R, now << 1 | 1);
      if(t[now << 1].rco == t[now << 1 | 1].lco) ret--;
      return ret;
    }
}
int query_col(int x, int now)
{
    if(t[now].l == t[now].r) return t[now].lco;
    pushdown(now);
    int mid = (t[now].l + t[now].r) >> 1;
    if(x <= mid) return query_col(x, now << 1);
    else return query_col(x, now << 1 | 1);
}

void update_path(int x, int y, int d)
{
  while(top[x] != top[y])
  {
      if(dep[top[x]] < dep[top[y]]) swap(x, y);
      update(dfsx[top[x]], dfsx[x], 1, d);
      x = fa[top[x]];
  }
  if(dep[x] > dep[y]) swap(x, y);
  update(dfsx[x], dfsx[y], 1, d);
}
int query_path(int x, int y)
{
    int ret = 0;
    while(top[x] != top[y])
    {
          if(dep[top[x]] < dep[top[y]]) swap(x, y);    
          ret += query(dfsx[top[x]], dfsx[x], 1);
          if(query_col(dfsx[top[x]], 1) == query_col(dfsx[fa[top[x]]], 1)) ret--;
          x = fa[top[x]];
    }
    if(dep[x] > dep[y]) swap(x, y);
    ret += query(dfsx[x], dfsx[y], 1);
    return ret;
}
  
char c[2];  
  
int main()
{
  n = read(); m = read();
  for(int i = 1; i <= n; ++i) a[i] = read();
  for(int i = 1; i < n; ++i)
    {
      int x = read(), y = read();
      v[x].push_back(y); v[y].push_back(x);
    }
  dfs1(1); Mem(vis, 0);
  top[1] = 1; dfs2(1);
  build(1, cnt, 1);
  for(int i = 1; i <= m; ++i)
    {
      scanf("%s", c); int L = read(), R = read();
      if(c[0] == 'C')
    {
      int x = read();
      update_path(L, R, x);
    }
      else write(query_path(L, R)), enter;
    }
  return 0;
}