树链剖分+线段树求子区间合并问题 [SDOI2011]染色（洛谷 P2486）

[SDOI2011]染色

题目大意：
给一颗n个结点的树，有两个操作：

1. 将节点 a 到节点 b 的路径上的所有点（包括 a 和 b）都染成颜色 c
2. 询问节点 a 到节点 b 的路径上的颜色段数量。

颜色段的定义是极长的连续相同颜色被认为是一段。例如 112221 由三段组成：11、222、1。

---

这题我觉得不是线段树染色的题，因为不是问你区间里面颜色的种类数，而是连续相同的颜色段数；

这就和前面做过的求子区间最大连续和等等问题非常类似，就是线合并过程中会有一些区别；因为是树上问题，剖成链是基本操作，但是链的合并过程中还有合并问题，跟线段树上的问题是一样的；

这个处理还是有技巧的，应为总是两条链进行合并，记录两条链的左区间颜色lc，当x和y进行交换时，lc也要进行交换；

当x和y都到一条链上时，两个lc都要满足；

代码：

#include<bits/stdc++.h>
#define LL long long
#define pa pair<int,int>
#define ls k<<1
#define rs k<<1|1
#define inf 0x3f3f3f3f
using namespace std;
const int N=100100;
const int M=50100;
const LL mod=1e9+7;
inline int read(){//非常重要的快速读入代码
	int x=0,sign=1;
	char c=getchar();
	while(c>'9'||c<'0'){//判断符号
		if(c=='-') sign=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9'){//转换数
		x=x*10+c-'0';
		c=getchar();
	}
	return x*sign;
}
char s[10];
int n,m,head[N],cnt,a[N];
int size[N],fa[N],son[N],deep[N];
int top[N],id[N],tot,w[N];
struct Node{
	int to,nex;
}edge[N*2];
void add(int p,int q){edge[cnt].to=q,edge[cnt].nex=head[p],head[p]=cnt++;}
void dfs1(int p,int fat){
	size[p]=1,fa[p]=fat;
	int mx=-1;
	for(int i=head[p];~i;i=edge[i].nex){
		int q=edge[i].to;
		if(q!=fat){
			deep[q]=deep[p]+1;
			dfs1(q,p);
			size[p]+=size[q];
			if(size[q]>mx) son[p]=q,mx=size[q];
		}
	}
}
void dfs2(int p,int topp){
	id[p]=++tot,top[p]=topp,w[tot]=a[p];
	if(!son[p]) return;//没有重儿子，也就是叶子结点 
	dfs2(son[p],topp);//先处理重儿子 
	for(int i=head[p];~i;i=edge[i].nex){
		int q=edge[i].to;
		if(q==fa[p]||q==son[p]) continue;
		dfs2(q,q);
	}
}

struct node{
	int l,r,lc,rc,lz,sum;
}tr[N*4];
void pp(int k){
	tr[k].sum=tr[ls].sum+tr[rs].sum;
	tr[k].lc=tr[ls].lc,tr[k].rc=tr[rs].rc;
	if(tr[ls].rc==tr[rs].lc) tr[k].sum-=1;
}
void pd(int k){
	if(tr[k].lz){
		tr[ls].lz=tr[rs].lz=tr[k].lz;
		tr[ls].sum=tr[rs].sum=1;
		tr[ls].lc=tr[ls].rc=tr[rs].lc=tr[rs].rc=tr[k].lz;
	}
	tr[k].lz=0;
}
void build(int l,int r,int k){
	tr[k].l=l,tr[k].r=r,tr[k].lz=0;
	if(l==r){
		tr[k].sum=1;
		tr[k].lc=tr[k].rc=w[l];
		return;
	}
	int d=(l+r)>>1;
	build(l,d,ls);
	build(d+1,r,rs);
	pp(k);
}
node query(int l,int r,int k){
	if(tr[k].l>=l&&tr[k].r<=r) return tr[k];
	pd(k);
	int d=(tr[k].l+tr[k].r)>>1;
	if(r<=d) return query(l,r,ls);
	else if(l>d) return query(l,r,rs);
	else{
		node x=query(l,r,ls),y=query(l,r,rs),z;
		z.lc=x.lc,z.rc=y.rc,z.sum=x.sum+y.sum;
		if(x.rc==y.lc) z.sum-=1;
		return z;
	}
}
int query_chain(int x,int y){
	int ans=0,lc1=0,lc2=0;
	while(top[x]!=top[y]){
		if(deep[top[x]]<deep[top[y]]){
			swap(x,y);//保证x结点的顶点更深 
			swap(lc1,lc2);
		}
		node z=query(id[top[x]],id[x],1);
		ans+=z.sum;
		if(lc1==z.rc) ans--;
		lc1=z.lc;
		x=fa[top[x]]; 
	}
	if(deep[x]<deep[y]){
		swap(x,y);//保证x结点的顶点更深 
		swap(lc1,lc2);
	}
	node z=query(id[y],id[x],1);
	ans+=z.sum;
	if(lc1==z.rc) ans--; 
	if(lc2==z.lc) ans--;
	return ans;
}
void update(int l,int r,int w,int k){
	if(tr[k].l>=l&&tr[k].r<=r){
		tr[k].sum=1;
		tr[k].lz=tr[k].lc=tr[k].rc=w;
		return;
	}
	pd(k);
	int d=(tr[k].l+tr[k].r)>>1;
	if(l<=d) update(l,r,w,ls);
	if(r>d) update(l,r,w,rs); 
	pp(k);
}
void update_chain(int x,int y,int z){
	while(top[x]!=top[y]){
		if(deep[top[x]]<deep[top[y]]) swap(x,y);//保证x结点的顶点更深 
		update(id[top[x]],id[x],z,1);
		x=fa[top[x]]; 
	}
	if(deep[x]<deep[y]) swap(x,y);
	update(id[y],id[x],z,1);
}

int main(){
	memset(head,-1,sizeof(head));
	n=read(),m=read(); 
	for(int i=1;i<=n;i++) a[i]=read();
	for(int i=1;i<n;i++){
		int u,v;u=read(),v=read();
		add(u,v),add(v,u);
	}
	dfs1(1,0),dfs2(1,1);
	build(1,n,1);
	while(m--){
		scanf("%s",s);
		if(s[0]=='Q'){
			int a,b;a=read(),b=read();
			printf("%d\n",query_chain(a,b));
		}
		else{
			int a,b,c;a=read(),b=read(),c=read();
			update_chain(a,b,c);
		}
	}
	return 0;
}