[伸展树&平衡树] Splay与Treap学习笔记（没有链表，链表最丑）

这两种树的学习资料真不好找，找到了又写的是丑陋的链表
给大家送一点Bonus，如果是二刷（并且像本蒟蒻一样第一遍没看懂）这两种树的同学可以进来点个赞了

二叉搜索树

二叉搜索树大家都很懂
中序遍历为原序列，维护左<根<右

可自己YY一下插入、删除、搜索的操作

Splay

旋一旋
自己想一想左儿子旋到根节点，右儿子旋到根节点

特别注意：
一条链的时候，不是莽起旋子节点，自己YY一条链看看哪样子旋减少了深度
是旋父节点再选子节点！
而这一步操作就是平衡的精髓

例 [HNOI2002]营业额统计
注意只能跟前面比，因此加一个点就计算一次
对于每次计算：先Splay，然后查询
Splay里面啥都干不了

#include<bits/stdc++.h>
using namespace std;
#define in Read()
int in{
	int i=0,f=1;char ch=0;
	while(!isdigit(ch)&&ch!='-') ch=getchar();
	if(ch=='-') ch=getchar(),f=-1;
	while(isdigit(ch)) i=(i<<1)+(i<<3)+ch-48,ch=getchar();
	return i*f;
}

const int N=33000;
int n,root,ans;
struct Tree{
	int lch,rch,fa,val;
	#define lch(p) tre[(p)].lch
	#define rch(p) tre[(p)].rch
	#define fa(p) tre[(p)].fa
	#define val(p) tre[(p)].val
}tre[N];

//void print_tree(int p){
//	printf("%d: %d %d\n",p,lch(p),rch(p));
//	if(lch(p)) print_tree(lch(p));
//	if(rch(p)) print_tree(rch(p));
//}

void insert(int p,int rt){
	if(val(p)<val(rt)){
		if(!lch(rt)){
			lch(rt)=p;
			fa(p)=rt;
		}else insert(p,lch(rt));
	}
	else{
		if(!rch(rt)){
			rch(rt)=p;
			fa(p)=rt;
		}else insert(p,rch(rt));
	}
	return;
}

bool as_right(int p){
	return p==rch(fa(p));
}

void rotate(int x){
	if(as_right(x)){
		int f=fa(x),s=lch(x);
		fa(x)=fa(f);
		as_right(f)?rch(fa(f))=x:lch(fa(f))=x;
		fa(f)=x;
		lch(x)=f;
		fa(s)=f;
		rch(f)=s;
	}else{
		int f=fa(x),s=rch(x);
		fa(x)=fa(f);
		as_right(f)?rch(fa(f))=x:lch(fa(f))=x;
		fa(f)=x;
		rch(x)=f;
		fa(s)=f;
		lch(f)=s;
	}
	return;
}

void splay(int x){
	while(fa(x)){
		int y=fa(x),z=fa(y);
		if(!z) rotate(x);
		else{
			if(as_right(x)==as_right(y))
				rotate(y),rotate(x);
			else
				rotate(x),rotate(x);
		}
	}
	root=x;
	return;
}

int qmin(int p){
	int res=lch(p);
	if(!res) return res;
	while(rch(res)) res=rch(res);
	return res;
}

int qmax(int p){
	int res=rch(p);
	if(!res) return res;
	while(lch(res)) res=lch(res);
	return res;
}

int query(int p){
	int pre=qmin(p),suf=qmax(p),res=2147483647;
	if(pre) res=min(res,val(p)-val(pre));
	if(suf) res=min(res,val(suf)-val(p));
	return res;
}

void solve(int p){
	insert(p,root);
	splay(p);
	ans+=query(p);//printf("ans+=%d\n",query(p));
	return;
}

int main(){
	n=in;
	val(1)=in;root=1;
	ans+=val(1);
	for(int i=2;i<=n;++i){
		val(i)=in;
		solve(i);
		//print_tree(root);
	}
	printf("%d\n",ans);
	return 0;
}

Debug

1. 查rotate：巧方法-认一个儿子认一个爸爸
2. 死循环看哪里出0了，死循环爆栈会MLE

Treap

例 文艺平衡树
仅需支持区间翻转操作（似乎还比普通平衡树要简单一点呢！）

Splay艹：把$l-1$旋到根节点，把$r+1$旋到根的右儿子，那么右儿子的左儿子就是要修改的区间，一顿旋转完事（打tag）
Treap艹：把$[l,r]$提出来（split操作），翻转一下，放回去

• merge操作：
  搜到叶节点，即可合并
  对于两棵树$u,v$，合并使$u$在左边，$v$在右边
  若$u$优先级小，则合并$u$的右儿子和$v$，合并后结果塞到$u$右儿子上去
• split操作：
  把根节点为$rt$的区间$[l,r]$分为$[l,k]$与$[k+1,r]$两段，并且根节点分别为$x,y$
  注意得到的根节点一定是“取出来”之后用的，不能用原树上记录的节点（因为操作过程中有改变$x,y$的步骤）
  这就有点类似权值线段树了（特别是$k$，注意搜右边的时候$k$要减，区间长度记得算根节点）

#include<bits/stdc++.h>
using namespace std;
#define in Read()
int in{
	int i=0,f=1;char ch=0;
	while(!isdigit(ch)&&ch!='-') ch=getchar();
	if(ch=='-') ch=getchar(),f=-1;
	while(isdigit(ch)) i=(i<<1)+(i<<3)+ch-48,ch=getchar();
	return i*f;
}

const int N=1e5+5;
int n,m,root,tot;
struct Tree{
	int lch,rch,siz,tag,pri,val;
	#define lch(p) tre[(p)].lch
	#define rch(p) tre[(p)].rch
	#define siz(p) tre[(p)].siz
	#define tag(p) tre[(p)].tag
	#define pri(p) tre[(p)].pri
	#define val(p) tre[(p)].val
}tre[N];

void push_up(int p){
	siz(p)=siz(lch(p))+siz(rch(p))+1;
	return;
}

void push_down(int p){
	if(!tag(p)) return;
	swap(lch(p),rch(p));
	tag(lch(p))^=1;
	tag(rch(p))^=1;
	tag(p)=0;
	return;
}

void print_tree(int p){
	push_down(p);
	if(lch(p)) print_tree(lch(p));
	printf("%d ",val(p));
	if(rch(p)) print_tree(rch(p));
	return;
}

int merge(int x,int y){
	if(!x||!y) return x+y;
	if(pri(x)<pri(y)){
		push_down(x);
		rch(x)=merge(rch(x),y);
		push_up(x);
		return x;
	}else{
		push_down(y);
		lch(y)=merge(x,lch(y));
		push_up(y);
		return y;
	}
}

void split(int rt,int k,int &x,int &y){
	if(!rt){
		x=y=0;
		return;
	}
	push_down(rt);
	if(k>=siz(lch(rt))+1){
		x=rt;
		split(rch(rt),k-siz(lch(rt))-1,rch(x),y);
	}else{
		y=rt;
		split(lch(rt),k,x,lch(y));
	}
	push_up(rt);
	return;
}

void insert(int id){
	++tot;
	val(tot)=id;
	pri(tot)=rand();
	siz(tot)=1;
	root=merge(root,tot);
	return;
}

void rollover(int l,int r){
	int x,y,z;
	split(root,r,x,y);
	split(x,l-1,x,z);
	tag(z)^=1;
	root=merge(merge(x,z),y);
	return;
}

int main(){
	srand(time(0));
	n=in,m=in;
	for(int i=1;i<=n;++i) insert(i);
	for(int i=1;i<=m;++i){
		int l=in,r=in;
		rollover(l,r);
	}
	print_tree(root);
	return 0;
}

后记

看了一下Splay的复杂度势能分析，可是势能分析正确性呢？
推荐我的题单哦