fhqTreap

fhqTreap

  为什么要学 $fhqTreap$ 呢，写 $splay$ 她不好吗qwq

  $fhqTreap$ 作为一种平衡树，她有很多优势，最重要的就是她好理解，码量小，而且实测下来还比 $splay$ 快，最重要的是她不用旋转！！！

  所以我们来学 $fhqTreap$ 吧qwq。

关于 split & merge

  和正常的 $treap$ 一样，这玩意儿的每个点上也有两个权值，一个是二叉查找树的权值 $tree$，另一个是堆的优先级 $heap$。

  然后我们就会考虑如何同时维护二叉查找树的性质和堆的性质，于是这里就有了两个在 $fhqTreap$ 里面非常重要的函数，也就是 $split()$ 和 $merge()$

  顾名思义，$split()$ 就是把一棵树分成两半，而 $merge()$ 就是把两棵树合并起来，首先我们先感受一下有了这两个操作之后剩下的东西会变得多么简单吧。

split(int k)

  首先，$split(k)$ 表示把一颗 $fpqTreap$ 按照权值 $k$ 划分成两部分，就比如我们对下图中的树进行 $split(6)$ 的操作，就会变成这样（这里标的每个点的权值都是 $tree$ 值而没有标 $heap$ 值）：

  可以这样感性理解一下，就是把小于等于 $6$ 的弄成一颗 $treap$，大于 $6$ 的弄成另一颗 $treap$，那么有了这个东西和 $merge()$（$merge$ 应该不用多说了吧，就是把分开的俩玩意儿合起来） 之后，其他的操作就会变得非常简单了：

  这里做一些规定，我们令 $split()$ 之后权值较小的树放在左边，后文会用左边的树或者 $x$ 来指代她，令权值较大的树放在右边，后文会用右边的树或者 $y$ 来指代她。并且令树 $x$ 的根为 $root(x)$。

insert(int x)

  首先是插入操作，比如说我们对下面这棵树进行 $insert(12)$ 的操作应该怎么做呢。

  非常简单啊，直接 $split(12)$，然后把 $12$ 接到左边的那颗树上，因为左边的都比 $12$ 小，所以直接接到最右边就可以了，然后再把两棵树 $merge()$ 起来就好了，是不是很简单呢，就像这样：

  注意这里是没有考虑 $heap$ 值的问题，但是可以感性理解一下，$insert()$ 工作就是这样完成的了。

delete(int x)

  众所周知 $splay$ 的 $delete()$ 真的是非常复杂，但是这里 $fhqTreap$ 的删除操作就非常简单了，我们考虑进行 $delete(k)$ 时直接 $split(k)$，然后会发现 $x$ 树上的值都有 $val\le k$，然后我们考虑把 $k$ 单独分出来，于是我们对于 $x$ 树再 $split(k-1)$，这样就分成了 $xx$ 树和 $xy$ 树，并且 $xy$ 树只有一个节点，并且这个节点的权值也就是 $k$。然后直接就不管 $xy$ 把 $xx$ 和 $y$ $merge()$ 起来就好了。

  下面的图解以 $delete(13)$ 为例（还是之前 $insert()$ 的时候用过的那颗树）：

getRankbyVal(int x)

  按值查排名，直接 $split(x-1)$ 然后再返回这棵树的 $size+1$ 就好了。

getValbyRank(int k)

  这个似乎只能像正常的平衡树那样写了~~~

prefix(int x)

  查前驱的话直接 $split(x-1)$ 然后返回 $x$ 树中最大的那个值，也就是在最右边的值，然后再 $merge()$ 回去就可以了。

sufix(int x)

  查后继的话直接 $split(x)$ 然后返回在 $y$ 树中最小的那个值，也就是最左边的值，然后再 $merge()$ 回去就可以了。

  怎么样，看完之后是不是感觉非常简单，除了按排名插值之外，所有的操作都有了自己的比普通的平衡树更简洁并且更易懂的写法。是不是感觉非常爽，那么接下来我们就来看看如何实现 $split()$ 和 $merge()$ 操作吧。

实现 split & merge

split(int p, int k, int &x, int &y)

  这个 $\text{split(int p, int k, int \&ls, int \&rs)}$ 函数就是上文说的按照 $k$ 分裂，只是上文中为了简单而把其他的几个变量省略了。

  $p$ 就表示当前节点，$ls$ 和 $rs$ 是需要修改的两个量也就是上一个当前节点的左儿子和右儿子。

  那么我们从根结点出发，对于遇到的每一个点，如果这个点的权值小于等于 $k$，那么就进到左子树里并且修改 $ls=p$，大于 $k$ 就进入右子树，并修改 $rs=p$，然后递归处理子树就好了：

void split(int p, int k, int &x, int &y){
	if(!p) x = y = 0;
	else{
		if(val[p] <= k) x = p, split(rs(p), k, rs(x), y);
		else y = p, split(ls(p), k, x, ls(y));
		up(p); 
	}
}

merge(int x, int y)

  把两个 $Treap$ 合并成一个的函数，并且保证 $x$ 树的权值小于 $y$ 树。这里就可以看成 $split()$ 的逆向操作就可以了：

int merge(int x, int y){
	if(!x or !y) return x + y;
	if(hep[x] < hep[y]){
		ch[x][1] = merge(rs(x), y), up(x); return x;
	}
	else{
		ch[y][0] = merge(x, ls(y)), up(y); return y;
	}
}

代码

#include<bits/stdc++.h>
using namespace std;
#define in read()
#define MAXN 100100
#define ls(p) ch[p][0]
#define rs(p) ch[p][1]

inline int read(){
	int x = 0; char c = getchar();
	while(c < '0' or c > '9') c = getchar();
	while('0' <= c and c <= '9')
		x = x * 10 + c - '0', c = getchar();
	return x;
}


int n = 0, root = 0;
int tot = 0;
int val[MAXN] = { 0 };
int hep[MAXN] = { 0 };
int siz[MAXN] = { 0 };
int ch[MAXN][2] = { 0 };

inline void up(int p) { siz[p] = siz[ls(p)] + siz[rs(p)] + 1; }
inline int cre(int v) { siz[++tot] = 1, val[tot] = v, hep[tot] = rand(); return tot; }

void split(int p, int k, int &x, int &y){
	if(!p) x = y = 0;
	else{
		if(val[p] <= k) x = p, split(rs(p), k, rs(x), y);
		else y = p, split(ls(p), k, x, ls(y));
		up(p); 
	}
}

int merge(int x, int y){
	if(!x or !y) return x + y;
	if(hep[x] < hep[y]){
		ch[x][1] = merge(rs(x), y), up(x); return x;
	}
	else{
		ch[y][0] = merge(x, ls(y)), up(y); return y;
	}
}

void ins(int k){
	int x = 0, y = 0;
	split(root, k, x, y);
	root = merge(merge(x, cre(k)), y);
}

void del(int k){
	int x = 0, y = 0, z = 0;
	split(root, k, x, z), split(x, k - 1, x, y);
	if(y) y = merge(ls(y), rs(y));
	root = merge(merge(x, y), z);
}

int rkbyval(int k){
	int x = 0, y = 0, ans = 0;
	split(root, k - 1, x, y);
	ans = siz[x] + 1;
	root = merge(x, y);
	return ans;
}

int valbyrk(int k){
	int p = root;
	while(114514){
		if(siz[ls(p)] + 1 == k) break;
		else if(siz[ls(p)] + 1 > k) p = ls(p);
		else k -= siz[ls(p)] + 1, p = rs(p);
	}
	return val[p];
}

int pre(int k){
	int x = 0, y = 0, p = 0, ans = 0;
	split(root, k - 1, x, y); p = x;
	while(rs(p)) p = rs(p);
	ans = val[p];
	root = merge(x, y);
	return ans;
}

int suf(int k){
	int x = 0, y = 0, p = 0, ans = 0;
	split(root, k, x, y); p = y;
	while(ls(p)) p = ls(p);
	ans = val[p];
	root = merge(x, y);
	return ans;
}

int main(){
	n = in; srand(time(0));
	while(n--){
		int op = in, x = in;
		if(op == 1) ins(x);
		if(op == 2) del(x);
		if(op == 3) cout << rkbyval(x) << '\n';
		if(op == 4) cout << valbyrk(x) << '\n';
		if(op == 5) cout << pre(x) << '\n';
		if(op == 6) cout << suf(x) << '\n';
	}
	return 0;
}