Treap，Splay & LCT 学习笔记

从二叉搜索树到平衡树

二叉搜索树（Binary Search Tree）是一种二叉树的树形数据结构，它维护一个集合，并保证它的中序遍历按照递增顺序给出了这个集合的所有元素。由此，可以完成插入，删除，查找元素，查询排名等操作：按照定义确定递归左子树或右子树即可。

可以看出 BST 的时间复杂度与树高相关，那么最优情况下可以达到单次操作 \(O(\log n)\)。但是 BST 很容易退化，最坏情况下会直接退化为链表。于是定义了 BST 的平衡。通常来说，“平衡”会定义为每个结点的左子树和右子树高度差不超过 \(1\)。但实际上在算法竞赛中，只要单次操作均摊 \(O(\log n)\)，就可以称作平衡树了。

对不满足平衡条件的 BST 进行调整，可以使它重新具有平衡性。基本的调整操作是旋转，又分为左旋和右旋。如图所示（图源 OI-wiki），对于结点 \(A\) 的右旋操作是指：将 \(A\) 的左孩子 \(B\) 向右上旋转，代替 \(A\) 成为根节点，将 \(A\) 结点向右下旋转成为 \(B\) 的右子树的根结点，\(B\) 的原来的右子树变为 \(A\) 的左子树。左旋类似。

一句话概括，左旋是让右儿子变成根结点，右旋是让左儿子变成根结点。

接下来介绍两种平衡树：Treap 和 Splay。其中 Treap 又可以分为有旋和无旋。

Treap

Treap=Tree+Heap。

顾名思义，Treap 是一棵满足堆性质的 BST。很显然这两个性质是矛盾的，这里的堆性质实际上是给每个元素额外赋予的一个值 priority。这个值是随机给出的。感性理解，这样随机化之后树高就是期望 \(O(\log n)\) 的。

旋转Treap

我们知道旋转是不改变 BST 性质的，所以用旋转维护堆性质就可以了。下面来具体考察一下每个操作。

• 插入：插入一个点之后，如果当前位置不满足堆性质，就要不断往上旋转。
• 删除：先找到这个点，如果这个点不是叶子，就先用旋转把它变成叶子结点，然后删掉。旋转过程中选择左右儿子中更大的一个转到根（假如是大根堆）。
• 查询排名，第 \(k\) 大，前驱，后继等操作不影响 BST 的结构，不需要额外说明。

注意实现的时候并不记录父亲结点，所以要区分左旋和右旋。模板题代码。

#include<bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const int N=1e5+10,INF=1<<30;
int Rand(int l=1,int r=(1<<29)){return rnd()%(r-l+1)+l;}
int rt,val[N],cnt[N],sz[N],ls[N],rs[N],pri[N],tot;
int node(int v){val[++tot]=v;pri[tot]=Rand();sz[tot]=cnt[tot]=1;return tot;}
void push_up(int p){sz[p]=cnt[p]+sz[ls[p]]+sz[rs[p]];}
void zig(int&p){int q=ls[p];ls[p]=rs[q];rs[q]=p;push_up(p);push_up(q);p=q;}
void zag(int&p){int q=rs[p];rs[p]=ls[q];ls[q]=p;push_up(p);push_up(q);p=q;}
void init(){rt=node(-INF);rs[rt]=node(INF);push_up(rt);}
void ins(int&p,int x){
    if(!p){p=node(x);return;}
    if(x==val[p])++cnt[p];
    else if(x<val[p]){ins(ls[p],x);if(pri[p]<pri[ls[p]])zig(p);}
    else {ins(rs[p],x);if(pri[p]<pri[rs[p]])zag(p);}
    push_up(p);
}
void del(int&p,int x){
    if(!p)return;
    if(x==val[p]){
        if(cnt[p]>1){--cnt[p];push_up(p);return;}
        if(ls[p]||rs[p]){
            if(!rs[p]||pri[ls[p]]>pri[rs[p]])zig(p),del(rs[p],x);
            else zag(p),del(ls[p],x); push_up(p);
        }else p=0; return;
    }
    if(x<val[p])del(ls[p],x);else del(rs[p],x);
    push_up(p);
}
int rnk(int p,int x){
    if(!p)return 1;
    if(x==val[p])return sz[ls[p]]+1;
    else if(x<val[p])return rnk(ls[p],x);
    else return sz[ls[p]]+cnt[p]+rnk(rs[p],x);
}
int kth(int p,int k){
    if(!p)return INF;
    if(k<=sz[ls[p]])return kth(ls[p],k);
    else if(k<=sz[ls[p]]+cnt[p])return val[p];
    else return kth(rs[p],k-sz[ls[p]]-cnt[p]);
}
int prev(int x){
    int p=rt,pre=-INF;
    while(p){
        if(val[p]<x)pre=val[p],p=rs[p];
        else p=ls[p];
    }
    return pre;
}
int next(int x){
    int p=rt,nxt=INF;
    while(p){
        if(val[p]>x)nxt=val[p],p=ls[p];
        else p=rs[p];
    }
    return nxt;
}
int main(){
    init();int q;scanf("%d",&q);
    while(q--){
        int op,x;scanf("%d%d",&op,&x);
        if(op==1)ins(rt,x);
        if(op==2)del(rt,x);
        if(op==3)printf("%d\n",rnk(rt,x)-1);
        if(op==4)printf("%d\n",kth(rt,x+1));
        if(op==5)printf("%d\n",prev(x));
        if(op==6)printf("%d\n",next(x));
    }
    return 0;
}

无旋Treap

无旋Treap，又称 Fhq-Treap，顾名思义就是不用旋转来满足堆性质的平衡树。它的两种基本操作是分裂与合并。

分裂（Split）是指将一棵 Treap 按照中序遍历的顺序分割成左右两半，满足两半组成的 Treap 所有值都不变。它需要一个参数 \(k\)，表示把中序遍历的前 \(k\) 个结点分离出来。具体实现很容易，要么一个子树的左子树和根都在第一棵树内，要么一个子树的右子树和根都在第二棵树内，于是递归下去就可以了。

合并（Merge）是将两棵（由原先的 Treap Split 得到的）Treap 合并在一起，按照中序遍历的顺序，并且所有结点的值都不变。注意第一棵树的所有数小于第二棵树的所有数。合并操作先比较两棵树的根的 pri 值决定以那个点为根，然后递归到子树内即可。

听起来很玄学，那么具体看看各种操作怎么实现。

• 查询排名和原来是一样的。
• 插入 \(x\)，先查询 \(x\) 的排名 \(k\)，然后按照 \(k\) 做一次 Split，把 \(x\) 看作一个新结点，做两次 Merge。
• 删除 \(x\)，先查询 \(x\) 的排名 \(k\)，然后按照 \(k-1,k\) 做两次 Split，丢掉中间那个点，把剩下两个树 Merge 起来。
• 查询第 \(k\) 大，按照 \(k-1,k\) 做两次 Split，然后中间那个就是需要的答案。
• 前驱就是 kth(rnk(val-1))。后继就是 kth(rnk(val+1))。

无旋 Treap 相较于带旋 Treap 的优势，除了常数和（可能）好写之外，更重要的是它的可拓展性。比如说，无旋 Treap 可以方便地支持区间操作：Split 操作得到的就是一个个区间。那么进一步，还可以像线段树一样打区间标记和懒惰标记，等等。

模板题代码。给每个结点记录一个翻转标记。

#include<bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
int Rand(int l=1,int r=(1<<29)){return rnd()%(r-l+1)+l;}
const int N=1e5+5;
int n,m;
int rt,val[N],sz[N],pri[N],ls[N],rs[N],tag[N],tot;
int node(int v){val[++tot]=v;sz[tot]=1;pri[tot]=Rand();return tot;}
void push_up(int p){sz[p]=sz[ls[p]]+sz[rs[p]]+1;}
void push_down(int p){
    if(!tag[p])return;tag[p]=0;
    tag[ls[p]]^=1;tag[rs[p]]^=1;swap(ls[p],rs[p]);
}
void split(int p,int k,int&u,int&v){
    if(!p){u=v=0;return;} push_down(p);
    if(k<=sz[ls[p]])v=p,split(ls[p],k,u,ls[p]);
    //如果分点在左子树中，那么把当前结点作为第二个子树的根
    //递归下去，两棵子树分别是第一个子树和当前结点的左儿子
    else u=p,split(rs[p],k-sz[ls[p]]-1,rs[p],v);
    push_up(p);
}
int merge(int p,int q){
    if(!p||!q)return p^q;
    if(pri[p]>pri[q]){//比较优先级
        push_down(p);rs[p]=merge(rs[p],q);
        push_up(p);return p;
    }
    else{
        push_down(q);ls[q]=merge(p,ls[q]);
        push_up(q);return q;
    }
}
void print(int p){
    if(!p)return;push_down(p);
    print(ls[p]),printf("%d ",val[p]),print(rs[p]);
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)node(i),rt=merge(rt,tot);
    for(int i=1,l,r;i<=m;i++){
        scanf("%d%d",&l,&r);int u,mid,v;
        split(rt,r,u,v);split(u,l-1,u,mid);
        tag[mid]^=1;rt=merge(merge(u,mid),v);
    }
    print(rt);
    return 0;
}

除了按照排名 Split，按照权值 Split 也是可以的。后者一般用在数字会有重复的情形下。但很多时候我们使用 Fhq-Treap 是为了按照顺序维护一个序列，所以并不常用。

Splay

Splay 树是一种均摊的平衡树，它也是用旋转来维持平衡的。这里和 Treap 的旋转可能略有区别，旋转是放在子结点上的，对左儿子的旋转叫右旋，对右儿子的旋转叫左旋。

Splay 树的独有操作是伸展（splay），即把一个点通过旋转变成根结点。一个直接的做法就是每一次都对目标结点旋转，这种做法称为单旋。然而单旋的复杂度是错误的，我们需要使用双旋。也就是说，我们额外判断一下当前结点的父结点是否同为左儿子（或同为右儿子），如果是，就先旋转父结点，再旋转子结点。

要维持平衡，只需要在每一次操作之后，都对最终访问的结点做 splay 操作。以 \(\sum \log(sz(x))\) 为势能函数分析可以得到复杂度。因此 splay 的实现并没有什么特殊的地方。

模板题代码。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5,INF=1e9;
int n;
struct Splay{
	int rt,tot,fa[N],ch[N][2],val[N],cnt[N],siz[N];
	void push_up(int p){siz[p]=siz[ch[p][0]]+siz[ch[p][1]]+cnt[p];}
	bool get(int p){return p==ch[fa[p]][1];}
	void clear(int p){fa[p]=ch[p][0]=ch[p][1]=val[p]=cnt[p]=siz[p]=0;}
	void rotate(int x){
		int y=fa[x],z=fa[y],op=1-get(x);
		ch[y][op^1]=ch[x][op];if(ch[x][op])fa[ch[x][op]]=y;
		ch[x][op]=y;fa[y]=x;fa[x]=z;if(z)ch[z][y==ch[z][1]]=x;
		push_up(y);push_up(x);
	}
	void splay(int x,int goal=0){
		for(int p=fa[x];p!=goal;p=fa[x]){
			if(fa[p]!=goal)rotate(get(p)==get(x)?p:x);
			rotate(x);
		}if(!goal)rt=x;
	}
	void ins(int v){
		if(!tot){rt=tot=1;val[1]=v;cnt[1]=siz[1]=1;return;}
		int p=rt,f=0;
		while(1){
			if(val[p]==v){++cnt[p];++siz[p];push_up(f);splay(p);break;}
			f=p;p=ch[p][val[p]<v];
			if(!p){
				val[p=++tot]=v;cnt[p]=siz[p]=1;
				fa[tot]=f;ch[f][val[f]<v]=p;
				push_up(f);splay(p);break;
			}
		}
	}
	bool find(int v){
		int p=rt;
		while(p){
			if(val[p]==v){splay(p);return true;}
			p=ch[p][val[p]<v];
		}return false;
	}
	void merge(int x,int y){
		while(ch[x][1])x=ch[x][1];
		splay(x);ch[x][1]=y;fa[y]=x;push_up(x);
	}
	void del(int v){
		if(!find(v))return;
		if(cnt[rt]>1){--cnt[rt],--siz[rt];return;}
		int x=ch[rt][0],y=ch[rt][1];
		fa[x]=fa[y]=0;clear(rt);
		if(!x||!y){rt=x+y;return;}
		merge(x,y);
	}
	int rank(int v){
		find(v);
		return siz[ch[rt][0]]+1;
	}
	int kth(int k){
		int p=rt;
		while(1){
			if(ch[p][0]&&k<=siz[ch[p][0]])p=ch[p][0];
			else{
				k-=cnt[p]+siz[ch[p][0]];
				if(k<=0){splay(p);return val[p];}
				p=ch[p][1];
			}
		}
	}
	int nxt(int x,int op){
		ins(x);int p=ch[rt][op^1];
		if(!p)return -1;
		while(ch[p][op])p=ch[p][op];
		int res=val[p];del(x);
		return res;
	}
}cst;
int main(){
	scanf("%d",&n);
	cst.ins(INF);cst.ins(-INF);
	for(int i=1,op,x;i<=n;i++){
		scanf("%d%d",&op,&x);
		if(op==1)cst.ins(x);
		if(op==2)cst.del(x);
		if(op==3)printf("%d\n",cst.rank(x)-1);
		if(op==4)printf("%d\n",cst.kth(x+1));
		if(op==5)printf("%d\n",cst.nxt(x,1));
		if(op==6)printf("%d\n",cst.nxt(x,0));
	}
	return 0;
}

Splay 和 Fhq-Treap 一样可以进行区间操作。具体来说，在 splay 的时候，我们不一定会将一个结点旋转到根，而是可以旋转到某个结点的儿子。这时，我们注意到在维护序列时，Splay 的一棵子树就代表一个区间，因此要提取区间 \([l,r]\)，只要先将 \(l-1\) splay 到根，再将 \(r+1\) splay 到根的右儿子，需要的子树就是 \(r+1\) 的左儿子。

模板题代码。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m,ans[N],cnt;
struct Splay{
	int rt,tot,fa[N],ch[N][2],val[N],tag[N],siz[N];
	void push_up(int p){siz[p]=siz[ch[p][0]]+siz[ch[p][1]]+1;}
	int build(int l,int r){
		if(l==r){push_up(l);return l;}
		int p=l+r>>1;
		if(l<p)fa[ch[p][0]=build(l,p-1)]=p;
		if(p<r)fa[ch[p][1]=build(p+1,r)]=p;
		push_up(p);
		return p;
	}
	bool get(int p){return p==ch[fa[p]][1];}
	void push_down(int p){
		if(!tag[p])return;
		tag[ch[p][0]]^=1;tag[ch[p][1]]^=1;
		tag[p]=0;swap(ch[p][0],ch[p][1]);
	}
	void rotate(int x){
		int y=fa[x],z=fa[y],op=get(x)^1;
		ch[y][op^1]=ch[x][op];if(ch[x][op])fa[ch[x][op]]=y;
		ch[x][op]=y;fa[y]=x;fa[x]=z;if(z)ch[z][y==ch[z][1]]=x;
		push_up(y);push_up(x);
	}
	void splay(int x,int goal){
		for(int p=fa[x];p!=goal;p=fa[x]){
			if(fa[p]!=goal)rotate(get(p)==get(x)?p:x);
			rotate(x);
		}if(!goal)rt=x;
	}
	int kth(int k){
		int p=rt;
		while(1){
			push_down(p);
			if(ch[p][0]&&k<=siz[ch[p][0]])p=ch[p][0];
			else{
				k-=siz[ch[p][0]]+1;
				if(k<=0)return p;
				p=ch[p][1];
			}
		}
	}
	void update(int l,int r){
		l=kth(l-1);splay(l,0);
		r=kth(r+1);splay(r,l);
		tag[ch[r][0]]^=1;
	}
	void dfs(int p){
		push_down(p);
		if(ch[p][0])dfs(ch[p][0]);
		if(p!=1&&p!=n+2)printf("%d ",p-1);
		if(ch[p][1])dfs(ch[p][1]);
	}
}cst;
int main(){
	scanf("%d%d",&n,&m);
	cst.rt=cst.build(1,n+2);
	for(int i=1,l,r;i<=m;i++){
		scanf("%d%d",&l,&r);
		cst.update(l+1,r+1);
	}
	cst.dfs(cst.rt);
	return 0;
}

LCT

写了两天平衡树突然不想写了。会补吗？会补的。