「luogu2486」[SDOI2011] 染色

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

轻重链剖分后，问题转化为一个链上的问题；

线段树维护区间内的颜色段数量，左端点、右端点的颜色；

线段树注意事项 {

　　合并时判断两个区间的相邻端点是否相同；

　　查询时同上，但要注意是否两段是不是都在查询区间内；

　　lazy_tag和更新颜色，嘻嘻嘻。

}

p.s 树上查询颜色段要判断两条链的端点是否颜色相同；

特别地，对于在同一条链上的两个节点之间的查询，要判断两个点和与它相邻点的颜色是否相同。

代码如下 :

 // 15owzLy1
 //luogu2486.cpp
 //2018 09 26      18:38:11
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define lson tl, mid, rt<<1
 #define rson mid+1, tr, rt<<1|1
 typedef long long ll;
 typedef double db;
 using namespace std;

 const int N = ;
 struct node { int l, r, cnt; };
 struct info {
     int next, to;
 }edge[N<<];
 int head[N], dfn[N], size[N], hson[N], fa[N], dep[N], q, n;
 int front[N], cl[N];

 template<typename T>inline void read(T &x_) {
     x_=;bool f_=;char c_=getchar();
     while(c_<''||c_>''){f_|=(c_=='-');c_=getchar();}
     while(c_>=''&&c_<=''){x_=(x_<<)+(x_<<)+(c_^);c_=getchar();}
     x_=f_?-x_:x_;
 }

 struct Segment_Tree {
     node t[N<<]; int lazy[N<<];
     inline void push_up(int rt) {
         t[rt].cnt=t[rt<<].cnt+t[rt<<|].cnt;
         if(t[rt<<].r==t[rt<<|].l) t[rt].cnt--;
         t[rt].l=t[rt<<].l, t[rt].r=t[rt<<|].r;
     }
     inline void spread(int rt) {
         t[rt<<].cnt=; t[rt<<|].cnt=;
         t[rt<<].l=t[rt<<|].r=t[rt<<].r=t[rt<<|].l=
         lazy[rt<<]=lazy[rt<<|]=lazy[rt];
         lazy[rt]=;
     }
     void update(int del, int l, int r, int tl, int tr, int rt) {
         if(l<=tl&&tr<=r) {
             t[rt].cnt=; t[rt].l=t[rt].r=lazy[rt]=del;
             return ;
         }
         if(lazy[rt]) spread(rt);
         int mid=(tl+tr)>>;
         if(mid>=l) update(del, l, r, lson);
         if(mid<r)  update(del, l, r, rson);
         push_up(rt);
     }
     int query(int l, int r, int tl, int tr, int rt) {
         if(l<=tl&&tr<=r) return t[rt].cnt;
         if(lazy[rt]) spread(rt);
         int mid=(tl+tr)>>, res=, k=;
         if(mid>=l) res+=query(l, r, lson), ++k;
         if(mid<r)  res+=query(l, r, rson), ++k;
         if(t[rt<<].r==t[rt<<|].l&&k>=) res--;
         return res;
     }
     int ask_cl(int pos, int tl, int tr, int rt) {
         if(tl==tr) return t[rt].l;
         if(lazy[rt]) spread(rt);
         int mid=(tl+tr)>>;
         if(mid>=pos)  return ask_cl(pos, lson);
         else          return ask_cl(pos, rson);
     }
 }T;

 inline void jb(int u, int v) {
     edge[++edge[].to].to=v;
     edge[edge[].to].next=head[u];
     head[u]=edge[].to;
 }

 void dfs(int u) {
     size[u]=;
     for(int i=head[u];i;i=edge[i].next) {
         int v=edge[i].to;
         if(v==fa[u]) continue;
         fa[v]=u; dep[v]=dep[u]+;
         dfs(v);
         size[u]+=size[v];
         if(size[hson[u]]<size[v]) hson[u]=v;
     }
 }

 inline void dfs_(int u, int father) {
     dfn[u]=++dfn[]; front[u]=father;
     if(hson[u]) dfs_(hson[u], father);
     for(int i=head[u];i;i=edge[i].next) {
         int v=edge[i].to;
         if(v==fa[u]||v==hson[u]) continue;
         dfs_(v, v);
     }
 }

 inline void update(int u, int v, int del) {
     while(front[u]!=front[v]) {
         if(dep[front[u]]>dep[front[v]]) swap(u, v);
         T.update(del, dfn[front[v]], dfn[v], , n, );
         v=fa[front[v]];
     }
     if(dep[u]>dep[v]) swap(u, v);
     T.update(del, dfn[u], dfn[v], , n, );
 }

 inline int query(int u, int v) {
     int res=, clu=-, clv=-, tmp, k=;
     while(front[u]!=front[v]) {
         if(dep[front[u]]>dep[front[v]])
             swap(u, v), swap(clu, clv);
         res+=T.query(dfn[front[v]], dfn[v], , n, );
         tmp=T.ask_cl(dfn[v], , n, );
         if(clv==tmp) --res;
         clv=T.ask_cl(dfn[front[v]], , n, );
         v=fa[front[v]];
     }
     if(dep[u]>dep[v])
         swap(u, v), swap(clu, clv);
     if(clu==T.ask_cl(dfn[u], , n, )) res--, ++k;
     if(clv==T.ask_cl(dfn[v], , n, )) res--, ++k;
     res+=T.query(dfn[u], dfn[v], , n, );
     return res;
 }

 int main() {
 #ifndef ONLINE_JUDGE
     freopen("luogu2486.in","r",stdin);
     freopen("luogu2486.out","w",stdout);
 #endif
     int x, y, z; char opt[];
     read(n), read(q);
     for(int i=;i<=n;i++) read(cl[i]);
     for(int i=;i<n;i++) read(x), read(y), jb(x, y), jb(y, x);
     dep[]=;
     dfs(); dfs_(,);
     for(int i=;i<=n;i++) T.update(cl[i], dfn[i], dfn[i], , n, );
     while(q--) {
         scanf("%s", opt); read(x), read(y);
         if(opt[]=='Q') printf("%d\n", query(x, y));
         else            read(z),    update(x, y, z);
     }
     return ;
 }