●洛谷P3348 [ZJOI2016]大森林

题链：

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

题解：

LCT，神题
首先有这么一个结论：
每次的1操作（改变生长点操作），一定只会会对连续的一段区间产生影响。
（即不存在对两段不相连的区间都进行了该操作的情况，令这种情况为[2]）
简单来说就是因为该操作需要对应的那些树存在那个节点。
如果发生了情况[2]，即表明区间[l1,r1],[l2,r2]有节点x，且[l1+1,r2-1]无节点x,且r2-1>=l1+1
但是我们的生长操作0操作每次进行的区间都是连续的，且每次产生的节点的编号都不同，
所以不会存在"区间[l1,r1],[l2,r2]有节点x，且[l1+1,r2-1]无节点x,且r2-1>=l1+1"这种情况
也就不会有情况[2]了。

所以，我们可以记录下来每种节点x的在哪段区间里L[x],R[x]。
然后对于一个1操作(1,l,r,x)，我们就可以得到其真正会影响的那段连续区间[max(l,L[x]),min(r,R[x])]
再强调一下，对于计算出来的区间[max(l,L[x]),min(r,R[x])]，该操作是一定会影响到的，同时也只会影响到该区间。

然后再看看由于询问保证一定给出的点存在，
所以既然我们都已经得到了1操作会真正影响的区间，那么对于所有的0操作（生长操作），
我们就可以忽略掉其给出的区间限制，而让整个[1,N]的区间都执行这个操作。
这样并不会影响答案。
(因为询问不会问到这个点，1操作也因为已经算出了其确切会影响的区间)。

由于树很多，不能同时维护这么多颗树，我们考虑离线，并用LCT维护
把所有操作和询问按其影响的区间的端点挂在对应的位置上，
依次维护每一颗树，并回答关于该树的问题。
同样由于询问保证一定给出的点存在，所以我们把询问放在最后来做。（即把当前树的形态维护好后，再回答所有询问）
然后是如何维护树的形态，
1.对于一个每一个1操作(1,l,r,x)，我们都新建一个虚节点，权值为0，
初始时该点先连在上一个虚节点上，之后所有的点都连在这个新的虚节点上面。
然后当到了第[max(l,L[x])颗树时，就让它连着它下面那一包东西，
先和它的父亲断开，再整体连到x对应的节点上去，实现了把之后的节点长在x上操作。
然后当到了第min(r,R[x])]+1颗树时，就让该虚点又连着它下面的那一包东西，回到之前的位置上去，实现了该操作没有影响的区间，生长节点不动这个操作。
2.对于一个0操作，因为我们让它对全区间生效，
所以只要遇到0操作，就把该操作对应的权值为1的节点link到上一个虚节点，以便之后随着虚节点被一起打包着走。
3.对于2操作，现在需要询问了，由于该树的形态已经维护好，所以直接找到两个点lca并回答即可。

（思路太妙啊，我都不知道下次遇到类似的题目能不能想出这种解法。2333）

代码：

#include<bits/stdc++.h>
#define MAXN 400005
using namespace std;
struct LCT{
int lnt;
int ch[MAXN][2],size[MAXN],val[MAXN],fa[MAXN];
LCT(){lnt=1;}
bool Who(int x){return ch[fa[x]][0]!=x;}
bool Isroot(int x){return ch[fa[x]][0]!=x&&ch[fa[x]][1]!=x;}
int Newnode(int v){
fa[lnt]=ch[lnt][0]=ch[lnt][1]=0;
size[lnt]=val[lnt]=v;
return lnt++;
}
void Pushup(int x){
size[x]=val[x];
if(ch[x][0]) size[x]+=size[ch[x][0]];
if(ch[x][1]) size[x]+=size[ch[x][1]];
}
void Rotate(int x){
static int y,z,l1,l2;
y=fa[x]; z=fa[y];
l1=Who(x); l2=Who(y); fa[x]=z;
if(!Isroot(y)) ch[z][l2]=x;
fa[ch[x][l1^1]]=y; fa[y]=x;
ch[y][l1]=ch[x][l1^1]; ch[x][l1^1]=y;
Pushup(y);
}
void Splay(int x){
static int y;
for(;y=fa[x],!Isroot(x);Rotate(x))
if(!Isroot(y)) Rotate(Who(y)==Who(x)?y:x);
Pushup(x);
}
int Access(int x){
static int y;
for(y=0;x;y=x,x=fa[x])
Splay(x),ch[x][1]=y,Pushup(x);
return y;
}
int Findlca(int x,int y){
Access(x); return Access(y);
}
void Link(int x,int y){
//Splay(y); It's not neccessary to do the Splay operation.
fa[x]=y;
}
void Cut(int x){
Access(x); Splay(x);
fa[ch[x][0]]=0; ch[x][0]=0; Pushup(x);
}
}DT;
struct Cmd{
int pos,odr,from,to;
Cmd(){}
Cmd(int _a,int _b,int _c,int _d):pos(_a),odr(_b),from(_c),to(_d){}
bool operator < (const Cmd &rtm) const{
return pos<rtm.pos||(pos==rtm.pos&&odr<rtm.odr);
}
}Q[MAXN];
int id[MAXN],L[MAXN],R[MAXN],ANS[MAXN];
int N,M,unreal,dnt=1,cnt=1;
int main(){
ios::sync_with_stdio(0);
cin>>N>>M;
L[dnt]=1; R[dnt]=N;
id[dnt++]=DT.Newnode(1);
unreal=DT.Newnode(0);
DT.Link(unreal,id[1]);
for(int i=1,t,l,r,x,tmp;i<=M;i++){
cin>>t;
switch(t){
case 0:
cin>>l>>r;
L[dnt]=l; R[dnt]=r;
id[dnt]=DT.Newnode(1);

Q[cnt++]=Cmd(1,i-M,id[dnt],unreal);
dnt++;
//Can the real node be linked to unreal node at now instead of doing this later?
//DT.Link(id[dnt],unreal);
//After the try,I found it okay to do this.
break;
case 1:
cin>>l>>r>>x;
l=max(l,L[x]); r=min(r,R[x]);
if(l<=r){
tmp=DT.Newnode(0);
DT.Link(tmp,unreal);
Q[cnt++]=Cmd(l,i-M,tmp,id[x]);
Q[cnt++]=Cmd(r+1,i-M,tmp,unreal);
unreal=tmp;
}
break;
case 2:
cin>>x>>l>>r;
Q[cnt++]=Cmd(x,i,id[l],id[r]);
break;
}
}
sort(Q+1,Q+cnt);
memset(ANS,-1,sizeof(ANS));
for(int tree=1,i=1,x,y;i<cnt&&tree<=N;tree++){
while(Q[i].pos==tree){
x=Q[i].from; y=Q[i].to;
if(Q[i].odr>0){
int l1,l2,l3,lca;
DT.Access(x); DT.Splay(x); l1=DT.size[x];
lca=DT.Findlca(x,y); DT.Access(lca); DT.Splay(lca); l2=DT.size[lca];
DT.Access(y); DT.Splay(y); l3=DT.size[y];
ANS[Q[i].odr]=l1+l3-2*l2;
}
else DT.Cut(x),DT.Link(x,y);
i++;
}
}
for(int i=1;i<=M;i++) if(ANS[i]>=0) cout<<ANS[i]<<endl;
return 0;
}