平衡树

普通平衡树

我们这里着重介绍一下 $fhq$ $treap$。

首先我们会用一个结构体存下平衡树的节点。这道题中需要存左右儿子编号，优先度（随机的一个值），点上存的数是多少，子树中有多少数。我们记作 $l,r,rd,da,siz$。

接下来我们一个一个讲解函数：

$newnode$ 新开点函数

考虑一个新点的五个值分别为 $0,0,rand,val,1$。代码：

int newnode(int val){
	tr[++cnt]={0,0,rand(),val,1};
	return cnt;
}

$pushup$ 上传函数

事实上，只有 $siz$ 需要上传，而一个点的 $siz$ 显然是左右儿子的 $siz$ 之和加上 $1$。代码：

void pushup(int p){
	tr[p].siz=tr[tr[p].l].siz+tr[tr[p].r].siz+1;
}

$split$ 分裂函数

同机房老哥写的 $spilt$，不好评价。

我们考虑按权值 $val$ 分裂，因为 $fhq$ $treap$ 的点上存的值满足左儿子小于等于自己小于等于右儿子（定义），所以我们假设把原树分成 $a$ 和 $b$，其中 $a$ 上的值全部不大于 $val$，$b$ 上的值全部大于 $val$。

首先如果遇到空节点直接返回即可。然后如果当前节点的值小于 $val$，那么把他和他的左子树划分给 $a$，递归分裂右子树；否则把他和他的右子树划分给 $b$，递归分裂左子树。最后在上传一下即可。代码：

void split(int p,int &a,int &b,int val){
	if(p==0){
		a=b=0;
		return;
	}
	if(tr[p].da<=val){
		a=p;
		split(tr[p].r,tr[a].r,b,val);
	}
	else{
		b=p;
		split(tr[p].l,a,tr[b].l,val);
	}
	pushup(p);
}

$merge$ 合并函数

首先基本对于所有数据结构的合并，都有在合并的两点其中一个为空时返回另一个（都空就返回空）。

然后我们维护的优先级 $rd$ 就派上用场了，我们维护的时候把优先级小的放在上面（大的也无所谓）。

假设我们要合并 $a,b$ 两棵树（前提条件 $a$ 中的所有值小于 $b$ 中的所有值，不难证明下文的所有用到 $merge$ 的地方都满足此要求），不妨设 $a$ 的 $rd$ 更小，那么由于 $b$ 中的值更大，我们把 $b$ 合并在 $a$ 的右子树，然后递归右子树并上传即可。反过来只需要合并在 $b$ 的左子树即可。代码：

int merge(int a,int b){
	if(!a||!b)return a+b;
	if(tr[a].rd<tr[b].rd){
		tr[a].r=merge(tr[a].r,b);
		pushup(a);
		return a;
	}
	else{
		tr[b].l=merge(a,tr[b].l);
		pushup(b);
		return b;
	} 
}

$ins$ 插入操作

因为下面的操作都比较简单，故代码统一在最后给出。

注意：所有在下文提到的原树按 $val$ 分裂为 $a,b$ 两树，均默认 $a$ 中所有数小于 $b$ 中所有数。

假设我们插入 $val$ 这个值，于是我们先按 $val$ 把原树分成 $a,b$ 两树。然后把 $val$ 这个单点合并到 $a$ 中，最后再把 $a,b$ 合回去。

$del$ 删除操作

首先还是把原树按删除值 $val$ 分成 $a,b$。然后考虑 $val$ 在 $a$ 最右边，于是再把 $a$ 按 $val-1$ 分成 $la,ra$ 两棵树。

这时显然 $ra$ 中有且仅有 $val$ 一个值，所以考虑删除 $ra$ 的根，一个经典的删除方法是，合并他的两个儿子。

最后再把所有东西原样合并回去即可。

$getrk$ 查找排名操作

考虑把原树按照查找值 $val$ 分成 $a,b$，于是答案就是 $a$ 的 $siz$ 再加 $1$（排名的定义），最后别忘了合并回去。

$find$ 根据排名找数操作

考虑一个平衡树上二分，我们设查的排名为 $rk$，当前点的左子树大小为 $siz$。然后分类讨论一下：

• $siz=rk$，返回当前点的值。

• $siz<rk$，在右子树中 $find(rk-siz)$。

• $siz>rk$，在左子树中 $find(rk)$。

$getpre$ 查找前驱操作

考虑把原树按照 $val-1$ 分成 $a,b$，于是 $val$ 的前驱为 $a$ 中最大的数，直接使用 $find$ 函数查找即可。

$getnxt$ 查找后继操作

考虑把原树按照 $val$ 分成 $a,b$，于是 $val$ 的后继为 $b$ 中最小的数，仍然直接使用 $find$ 函数查找即可。

完整代码：

#include<bits/stdc++.h>
#define int long long
#define N 100005
using namespace std;
struct fhq{
	int rt,cnt;
	struct node{
		int l,r,rd,da,siz;
	}tr[N];
	int newnode(int val){
		tr[++cnt]={0,0,rand(),val,1};
		return cnt;
	}
	void pushup(int p){
		tr[p].siz=tr[tr[p].l].siz+tr[tr[p].r].siz+1;
	}
	void split(int p,int &a,int &b,int val){
		if(p==0){
			a=b=0;
			return;
		}
		if(tr[p].da<=val){
			a=p;
			split(tr[p].r,tr[a].r,b,val);
		}
		else{
			b=p;
			split(tr[p].l,a,tr[b].l,val);
		}
		pushup(p);
	}
	int merge(int a,int b){
		if(!a||!b)return a+b;
		if(tr[a].rd<tr[b].rd){
			tr[a].r=merge(tr[a].r,b);
			pushup(a);
			return a;
		}
		else{
			tr[b].l=merge(a,tr[b].l);
			pushup(b);
			return b;
		} 
	}
	void ins(int val){
		int l,r;
		split(rt,l,r,val);
		rt=merge(merge(l,newnode(val)),r);
	}
	void del(int val){
		int l,r,ll,lr;
		split(rt,l,r,val);
		split(l,ll,lr,val-1);
		lr=merge(tr[lr].l,tr[lr].r);
		rt=merge(merge(ll,lr),r);
	}
	int get_rk(int val){
		int l,r;
		split(rt,l,r,val-1);
		int res=tr[l].siz+1;
		rt=merge(l,r);
		return res;
	}
	int find(int p,int rk){
		int siz=tr[tr[p].l].siz+1;
		if(siz==rk)return tr[p].da;
		else if(siz<rk)return find(tr[p].r,rk-siz);
		else return find(tr[p].l,rk);
	}
	int get_pre(int val){
		int l,r;
		split(rt,l,r,val-1);
		int res=find(l,tr[l].siz);
		rt=merge(l,r);
		return res;
	}
	int get_nxt(int val){
		int l,r;
		split(rt,l,r,val);
		int res=find(r,1);
		rt=merge(l,r);
		return res;
	}
}fhq;
signed main(){
	srand(time(0));
	int n;
	cin>>n;
	while(n--){
		int op,x;
		cin>>op>>x;
		if(op==1)fhq.ins(x);
		else if(op==2)fhq.del(x);
		else if(op==3)cout<<fhq.get_rk(x)<<'\n';
		else if(op==4)cout<<fhq.find(fhq.rt,x)<<'\n';
		else if(op==5)cout<<fhq.get_pre(x)<<'\n';
		else cout<<fhq.get_nxt(x)<<'\n';
	}
	return 0;
}

文艺平衡树

考虑这样一棵树，如果我们要输出他，就是输出他的中序遍历。

如果翻过来的话，就相当于反着输出中序遍历。

对于每一次操作，我们可以分裂出该区间代表的树，然后开始交换儿子。

但是发现这样巨慢无比，考虑线段树的区间修改也有这样的问题，于是我们打懒标记即可。

现在就只有一个问题，如何分裂出所在区间的树？考虑另一种经典的分裂：按照大小分裂。

我们每次分裂出前 $siz$ 个数，这个过程可以使用平衡树上二分完成（注意这个二分和通常意义上的不同）。于是我们先分出前 $l-1$ 个数，再在后一棵树中分出前 $r-l+1$ 个数，然后打懒标记即可。

代码：

#include<bits/stdc++.h>
#define int long long
#define N 100005
using namespace std;
struct fhq{
	struct node{
		int l,r,rd,da,siz,lzy;
	}tr[N];
	int rt=0,cnt=0;
	int newnode(int val){
		tr[++cnt]={0,0,rand(),val,1,0};
		return cnt;
	}
	void pushup(int p){
		tr[p].siz=tr[tr[p].l].siz+tr[tr[p].r].siz+1;
	}
	void pushdown(int p){
		if(!tr[p].lzy)return;
		swap(tr[p].l,tr[p].r);
		tr[tr[p].l].lzy^=1;
		tr[tr[p].r].lzy^=1;
		tr[p].lzy^=1;
	}
	void split(int p,int &a,int &b,int siz){
		if(p==0){
			a=b=0;
			return;
		}
		pushdown(p);
		if(tr[tr[p].l].siz+1<=siz){
			a=p;
			split(tr[p].r,tr[a].r,b,siz-tr[tr[p].l].siz-1);
		}
		else{
			b=p;
			split(tr[p].l,a,tr[b].l,siz);
		}
		pushup(p);
	}
	int merge(int a,int b){
		if(!a||!b)return a+b;
		if(tr[a].rd<tr[b].rd){
			pushdown(a);
			tr[a].r=merge(tr[a].r,b);
			pushup(a);
			return a;
		}
		else{
			pushdown(b);
			tr[b].l=merge(a,tr[b].l);
			pushup(b);
			return b;
		}
	}
	void solve(int l,int r){
		int x,y,yl,yr;
		split(rt,x,y,l-1);
		split(y,yl,yr,r-l+1);
		tr[yl].lzy^=1;
		rt=merge(x,merge(yl,yr));
	}
	void print(int p){
		if(p==0)return;
		pushdown(p);
		print(tr[p].l);
		cout<<tr[p].da<<' ';
		print(tr[p].r);
	}
}fhq;
signed main(){
	srand(time(0));
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		fhq.rt=fhq.merge(fhq.rt,fhq.newnode(i));
	}
	while(m--){
		int l,r;
		cin>>l>>r;
		fhq.solve(l,r);
	}
	fhq.print(fhq.rt);
	return 0;
}