「ZJOI2016」大森林 解题报告

「ZJOI2016」大森林

神仙题...

很显然线段树搞不了

考虑离线操作

我们只搞一颗树，从位置1一直往后移动，然后维护它的形态试试

显然操作0,1都可以拆成差分的形式，就是加入和删除

因为保证了操作2的合法性，我们不妨先不计合法性把所有点加到树中

显然每个点要连到在这个点之前的离这个点时间上最近那个1操作的点上

然后可以发现移动时1操作相当于很多个点换根

我们可以对每个1操作建一个虚点，然后就可以很方便换根了

那么如何保证查询操作呢？

可以把每个1操作的虚点大小设成0(代表它父亲边的直接长度)，并按时间串起来。

这样，一个虚点的虚点儿子的子树的点其实也是它的子树了，查询的时候差dis[u]+dis[v]-dis[lca]*2就可以了

是不是以为这个0操作的区间限制就没有用了？

其实不是，注意到1操作的点可能还没出现...这时候就要把1操作删掉

---

Code:

#include <cstdio>
#include <cctype>
#include <algorithm>
using std::min;
using std::max;
const int N=3e5+10;
template <class T>
void read(T &x)
{
	x=0;char c=getchar();
	while(!isdigit(c)) c=getchar();
	while(isdigit(c)) x=x*10+c-'0',c=getchar();
}
int ans[N],n,m,_n,_m,q,p[N],node,ti[N],tot,L[N],R[N];
struct koito_yuu
{
	int pos,op,u,v;
	koito_yuu(){}
	koito_yuu(int Pos,int Op,int U,int V){pos=Pos,op=Op,u=U,v=V;}
	bool friend operator <(koito_yuu a,koito_yuu b){return a.pos==b.pos?a.op<b.op:a.pos<b.pos;}
}yuu[N];
#define ls ch[now][0]
#define rs ch[now][1]
#define fa par[now]
int sum[N],ch[N][2],par[N],siz[N];
bool isroot(int now){return ch[fa][0]==now||ch[fa][1]==now;}
int identity(int now){return ch[fa][1]==now;}
void connect(int f,int now,int typ){ch[fa=f][typ]=now;}
void updata(int now){sum[now]=sum[ls]+sum[rs]+siz[now];}
void Rotate(int now)
{
	int p=fa,typ=identity(now);
	connect(p,ch[now][typ^1],typ);
	if(isroot(p)) connect(par[p],now,identity(p));
	else fa=par[p];
	connect(now,p,typ^1);
	updata(p),updata(now);
}
void splay(int now)
{
	for(;isroot(now);Rotate(now))
		if(isroot(fa))
			Rotate(identity(now)^identity(fa)?now:fa);
}
int access(int now)
{
	int las=0;
	for(;now;las=now,now=fa) splay(now),rs=las,updata(now);
	return las;
}
int LCA(int x,int y)
{
	access(x);
	return access(y);
}
void link(int x,int y)
{
	access(x),splay(x);
	par[x]=y;
}
void cat(int x)
{
	access(x),splay(x);
	par[ch[x][0]]=0;
	ch[x][0]=0;
}
int qry(int x)
{
	access(x),splay(x);
	return sum[x];
}
int query(int x,int y)
{
	int lca=LCA(x,y);
	return qry(x)+qry(y)-(qry(lca)<<1);
}
int main()
{
	read(n),read(m);
    L[1]=1,R[1]=n,node=1,++tot;
	for(int op,l,r,x,u,v,i=1;i<=m;i++)
	{
		read(op);
		if(op==0) ++node,read(L[node]),read(R[node]),p[node]=i;
		else if(op==1)
		{
			ti[++tot]=i;
			link(tot,tot-1);
			read(l),read(r),read(x);
			l=max(L[x],l),r=min(R[x],r);
			if(l>r) continue;
			yuu[++q]=koito_yuu(l,-1,x,tot);
			yuu[++q]=koito_yuu(r+1,0,x,tot);
		}
		else
		{
			read(x),read(u),read(v);
			yuu[++q]=koito_yuu(x,++_n,u,v);
		}
	}
	_m=tot;
	for(int i=2;i<=node;i++)
	{
		int pos=std::upper_bound(ti+1,ti+1+_m,p[i])-ti-1;
		siz[++tot]=1,sum[tot]=1;
		link(tot,pos);
	}
	std::sort(yuu+1,yuu+1+q);
	for(int j=1,i=1;i<=n;i++)
	{
		while(yuu[j].pos==i)
		{
		    int u=yuu[j].u+_m-1,v=yuu[j].v;
		    if(u==_m) u=1;
			if(yuu[j].op==-1)
			{
				cat(v);
				link(v,u);
			}
			else if(yuu[j].op==0)
			{
				cat(v);
				link(v,v-1);
			}
			else ans[yuu[j].op]=query(u,v==1?1:v+_m-1);
			++j;
		}
	}
	for(int i=1;i<=_n;i++) printf("%d\n",ans[i]);
	return 0;
}

---

2019.3.11