算法六期-第十课-平衡树-上课笔记（无旋Treap）

无旋 $Treap$

  FHQ Treap

 特点：所有的操作只用到了分裂和合并两种操作。且所有时间复杂度都为 $O(\log n)$

分裂

将树拆为两棵子树 L，R

以键值为对象进行分裂

x是分裂时的基准值

L为根的子树上所有节点的键值都小于或等于x

R为根的子树上所有节点的键值都大于x。

分治的思想进行分裂

步骤：

1. 当前的节点键值<=x

   1. 更新L为当前节点
   2. 继续在右子树上进行分裂

2. 当前节点的键值 >x

   1. 更新R为当前节点
   2. 继续在左子树上进行分裂

void Split(int u,int x,int &L,int &R){//权值分裂 
	//u：当前treap树的根节点 
	//x:分裂的基准值 
	//L、R 分裂后的左右子树的根节点
	if(u==0){ 
		L=R=0;//到达叶子结点直接返回 
		return ;
	}
	
	if(t[u].val<=x){
		L=u;//更新L为当前节点
		Split(t[u].rs,x,t[u].rs,R);
	}else{
		R=u;
		Split(t[u].ls,x,L,t[u].ls);
	}
	Update(u);//更新 
}

合并

int Merge(int L,int R){//根据优先级合并、尽可能保持平衡  称为排序树 
	if(L==0||R==0) return L+R;//任意一棵子树为空的处理 将新树的根选为优先级更大的那个 
	if(t[L].pri > t[R].pri){
		t[L].rs=Merge(t[L].rs,R);
		Update(L);
		return L;
	}else{
		t[R].ls=Merge(L,t[R].ls);
		Update(R);
		return R;
	}
}

完整代码（模板题）

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int cnt=0,root;//cnt-节点存储到数组中的为止  root 树根
struct node{
	int ls,rs;//左右孩子 
	int val,pri;//键值、优先级
	int size;//以当前节点为根的子树节点总数 
}t[N];

int newNode(int x){
	t[++cnt].val=x;
	t[cnt].pri=rand();
	t[cnt].ls=t[cnt].rs=0;
	t[cnt].size=1;
	return cnt;
}

void Update(int u){
	t[u].size=t[t[u].ls].size+t[t[u].rs].size+1;
}

void Split(int u,int x,int &L,int &R){//权值分裂 
	//u：当前treap树的根节点 
	//x:分裂的基准值 
	//L、R 分裂后的左右子树的根节点
	if(u==0){ 
		L=R=0;//到达叶子结点直接返回 
		return ;
	}
	
	if(t[u].val<=x){
		L=u;//更新L为当前节点
		Split(t[u].rs,x,t[u].rs,R);
	}else{
		R=u;
		Split(t[u].ls,x,L,t[u].ls);
	}
	Update(u);//更新 
}

int Merge(int L,int R){//根据优先级合并、尽可能保持平衡  称为排序树 
	if(L==0||R==0) return L+R;//任意一棵子树为空的处理 将新树的根选为优先级更大的那个 
	if(t[L].pri > t[R].pri){
		t[L].rs=Merge(t[L].rs,R);
		Update(L);
		return L;
	}else{
		t[R].ls=Merge(L,t[R].ls);
		Update(R);
		return R;
	}
}

void Insert(int x){//将x插入Treap中
	int L,R;
	Split(root,x,L,R); //分裂成<=x 和 >x 的两棵树 
	int aa=Merge(L,newNode(x));//合并 L和新节点 
	root=Merge(aa,R);//合并左、右 两个树 
}

void Del(int x){
	int L,R,p;
	Split(root,x,L,R);
	Split(L,x-1,L,p);
	p=Merge(t[p].ls,t[p].rs);
	root=Merge(Merge(L,p),R);
} 

int  Rank(int x){
	int L,R;
	Split(root,x-1,L,R);
	int ans=t[L].size+1;//<x的节点个数加一
	root=Merge(L,R);//重新合并回去 
	return ans;
}

int kth(int u,int k){
	if(k==t[t[u].ls].size+1) return u;//当前节点为第k个，直接返回
	else if(k<=t[t[u].ls].size) return kth(t[u].ls,k); //排名小于左子树节点个数,在左子树上找
	else return kth(t[u].rs,k-t[t[u].ls].size-1);//排名大于左子树节点个数，在有字数上找 
} 

int Precursor(int x){
	int L,R;
	Split(root,x-1,L,R);
	int ans=t[kth(L,t[L].size)].val;
	root=Merge(L,R);
	return ans;
} 

int Successor(int x){
	int L,R;
	Split(root,x,L,R);
	int ans=t[kth(R,1)].val;
	root=Merge(L,R);
	return ans;
}
int main()
{
	srand(time(NULL));
	int n,op,x;
	cin>>n;
	while(n--){
		cin>>op>>x;
		switch(op){
			case 1:Insert(x);break;
			case 2:Del(x);break;
			case 3:printf("%d\n",Rank(x));break;
			case 4:printf("%d\n",t[kth(root,x)].val);break;
			case 5:printf("%d\n",Precursor(x));break;
			case 6:printf("%d\n",Successor(x));break; 
		}
	}
 	return 0;
}

P1486 [NOI2004] 郁闷的出纳员

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int cnt=0,root;//cnt-节点存储到数组中的为止  root 树根
int n,m,add,ans; 
struct node{
	int ls,rs;//左右孩子 
	int val,pri;//键值、优先级
	int size;//以当前节点为根的子树节点总数 
}t[N];

int newNode(int x){
	t[++cnt].val=x;
	t[cnt].pri=rand();
	t[cnt].ls=t[cnt].rs=0;
	t[cnt].size=1;
	return cnt;
}

void Update(int u){
	t[u].size=t[t[u].ls].size+t[t[u].rs].size+1;
}

void Split(int u,int x,int &L,int &R){//权值分裂 
	//u：当前treap树的根节点 
	//x:分裂的基准值 
	//L、R 分裂后的左右子树的根节点
	if(u==0){ 
		L=R=0;//到达叶子结点直接返回 
		return ;
	}
	
	if(t[u].val<=x){
		L=u;//更新L为当前节点
		Split(t[u].rs,x,t[u].rs,R);
	}else{
		R=u;
		Split(t[u].ls,x,L,t[u].ls);
	}
	Update(u);//更新 
}

int Merge(int L,int R){//根据优先级合并、尽可能保持平衡  称为排序树 
	if(L==0||R==0) return L+R;//任意一棵子树为空的处理 将新树的根选为优先级更大的那个 
	if(t[L].pri > t[R].pri){
		t[L].rs=Merge(t[L].rs,R);
		Update(L);
		return L;
	}else{
		t[R].ls=Merge(L,t[R].ls);
		Update(R);
		return R;
	}
}

void Insert(int x){//将x插入Treap中
	int L,R;
	Split(root,x,L,R); //分裂成<=x 和 >x 的两棵树 
	int aa=Merge(L,newNode(x));//合并 L和新节点 
	root=Merge(aa,R);//合并左、右 两个树 
}

void Del(int x){
	//1.分裂成 L,R 
	//L:<=x  R:>x
	int L,R;
	Split(root,x,L,R);
	root=R;
	ans+=t[L].size;
}

int Kth(int k){//从大到小的第k个 
	int u=root;
	while(t[t[u].rs].size!=k-1){
		if(t[t[u].rs].size >= k) u=t[u].rs;
		else{
			k=k-t[t[u].rs].size-1;
			u=t[u].ls;
		}
	}
	return u;
}

int main()
{
	char c;
	int k;
	srand(time(NULL));
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>c>>k;
		if(c=='I'){
			if(k>=m) Insert(k-add);
		}else if(c=='A') add+=k;
		else if(c=='S'){
			add-=k;
			Del(m-1-add);
		}else{
			if(t[root].size<k) printf("-1\n");
			else printf("%d\n",t[Kth(k)].val+add);
		}
	}
	printf("%d\n",ans);
 	return 0;
}