[NOI2021] 轻重边
气死我了这题，还是写一下题解
首先有一个非常好的转化，你可以把给定操作转为树上颜色问题
假设将操作 \(1\) 改成 “将从 \(x\) 到 \(y\) 路径上的所有点都涂上一种新的颜色”，那么可以发现，与路径上的点相邻的所有非路径点，与路径上的点颜色必然不同，路径上的点之间两两必然相同
因此就可以定义重边为 “端点颜色相同的边”，轻边为 “端点颜色不同的边”，这样就可以将原问题转为树上数颜色问题
转化到这里就很好做了，由于数颜色是合并连通块，可以直接树剖之后放到线段树上去做，维护当前连续段长度，左端点，右端点，然后每次尝试在中间合并（合并最多只会增加 \(1\) 的贡献）
操作要求我们支持区间修改与区间查询
对于区间修改，修改后整体覆盖的区间，其连通块个数应为 \(len-1\) 而不是 \(len\)，因为我们求的是联通的边数而不是点数
对于区间查询，同样维护长度，左端点与右端点，询问时分治并尝试在中间合并
然后是这个树剖的查询操作，这里不能无脑跳，因为我们需要合并连续段，因此必须知道当前链哪端是左边哪端是右边，这个可以通过维护一个变量来记录当前跳的是左边点还是右边点，然后通过深度低的点更靠左来判断左右端点
这个题需要特判颜色初值 \(0\)，因为 \(0\) 和 \(0\) 不能被称为颜色相等的点（初始所有点都是轻边）
因为懒得特判所以为点赋了不同初值，没想到最后发现和树剖的初值在值域上有交
#include<bits/stdc++.h>
using namespace std;
#define clearzero(x) memset((x),0,sizeof(x))
struct tree{
int lc,rc;
int lazy;
int tot;
}t[100001*4];
int wnew[100001];
#define tol (id*2)
#define tor (id*2+1)
#define mid(l,r) mid=((l)+(r))/2
void pushdown(int id,int l,int r){
if(t[id].lazy){
int mid(l,r);
t[tol]={t[id].lazy,t[id].lazy,t[id].lazy,mid-l};
t[tor]={t[id].lazy,t[id].lazy,t[id].lazy,r-(mid+1)};
t[id].lazy=0;
}
}
void update(int id){
t[id].lc=t[tol].lc;
t[id].rc=t[tor].rc;
t[id].tot=t[tol].tot+t[tor].tot+(t[tol].rc==t[tor].lc);
}
void build(int id,int l,int r){
if(l==r){
t[id]={-wnew[l],-wnew[l],0,0};
return;
}
int mid(l,r);
build(tol,l,mid);
build(tor,mid+1,r);
update(id);
}
void change(int id,int l,int r,int L,int R,int val){
if(L<=l and r<=R){
t[id]={val,val,val,r-l};
return;
}
pushdown(id,l,r);
int mid(l,r);
if(R<=mid) change(tol,l,mid,L,R,val);
else if(L>=mid+1) change(tor,mid+1,r,L,R,val);
else{
change(tol,l,mid,L,mid,val);
change(tor,mid+1,r,mid+1,R,val);
}
update(id);
}
tree ask(int id,int l,int r,int L,int R){
if(L<=l and r<=R){
return t[id];
}
pushdown(id,l,r);
int mid(l,r);
if(R<=mid) return ask(tol,l,mid,L,R);
else if(L>=mid+1) return ask(tor,mid+1,r,L,R);
tree a=ask(tol,l,mid,L,mid),b=ask(tor,mid+1,r,mid+1,R);
return {a.lc,b.rc,0,a.tot+b.tot+(a.rc==b.lc)};
}
int n,m;
vector<int>e[100001];
int deep[100001],fa[100001];
int size[100001],maxson[100001];
int id[100001],top[100001],idcnt;
int dfn[100001],dfncnt;
void dfs1(int now,int last){
fa[now]=last;
deep[now]=deep[last]+1;
dfn[last]=++dfncnt;
size[now]=1;
int maxsonsize=0;
for(int i:e[now]){
if(i!=last){
dfs1(i,now);
size[now]+=size[i];
if(size[i]>maxsonsize){
maxsonsize=size[i];
maxson[now]=i;
}
}
}
}
void dfs2(int now,int nowtop){
top[now]=nowtop;
id[now]=++idcnt;
if(!maxson[now]) return;
dfs2(maxson[now],nowtop);
for(int i:e[now]){
if(i!=fa[now] and i!=maxson[now]){
dfs2(i,i);
}
}
}
void change_path(int x,int y,int val){
while(top[x]!=top[y]){
if(deep[top[x]]<deep[top[y]]) swap(x,y);
change(1,1,n,id[top[x]],id[x],val);
x=fa[top[x]];
}
if(deep[x]<deep[y]) swap(x,y);
change(1,1,n,id[y],id[x],val);
}
int ask_path(int x,int y){
tree ans1={-1-2*n,-2-2*n,0,0},ans2={-3-2*n,-4-2*n,0,0};
bool isans1=true;
while(top[x]!=top[y]){
if(deep[top[x]]<deep[top[y]]){
isans1^=1;
swap(x,y);
}
tree res=ask(1,1,n,id[top[x]],id[x]);
if(isans1){
ans1={ans1.lc,res.lc,0,ans1.tot+res.tot+(ans1.rc==res.rc)};
}
else{
ans2={res.lc,ans2.rc,0,ans2.tot+res.tot+(ans2.lc==res.rc)};
}
x=fa[top[x]];
}
if(deep[x]<deep[y]){
isans1^=1;
swap(x,y);
}
tree res=ask(1,1,n,id[y],id[x]);
if(isans1){
ans1={ans1.lc,res.lc,0,ans1.tot+res.tot+(ans1.rc==res.rc)};
}
else{
ans2={res.lc,ans2.rc,0,ans2.tot+res.tot+(ans2.lc==res.rc)};
}
return ans1.tot+ans2.tot+(ans1.rc==ans2.lc);
}
void clear(){
idcnt=0;
dfncnt=0;
clearzero(t);
clearzero(wnew);
clearzero(id);
clearzero(fa);
clearzero(deep);
clearzero(size);
clearzero(maxson);
clearzero(top);
clearzero(dfn);
for(int i=1;i<=n;++i){
e[i].clear();
}
}
int main(){
int t;cin>>t;
while(t--){
cin>>n>>m;
clear();
for(int i=1;i<=n-1;++i){
int x,y;
cin>>x>>y;
e[x].push_back(y);
e[y].push_back(x);
}
dfs1(1,0);
dfs2(1,1);
iota(wnew+1,wnew+n+1,1);
build(1,1,n);
for(int i=1;i<=m;++i){
int opt,x,y;
cin>>opt>>x>>y;
if(opt==1){
change_path(x,y,i);
}
else{
cout<<ask_path(x,y)<<'\n';
}
}
}
}
