$\text{fhq-treap}$总结

\(\text{fhq-treap}\)总结

又名范浩强\(\text{treap}\)，是一种无旋\(\text{treap}\)。其原理同\(\text{treap}\)一样都是通过维护一个随机堆来避免退化为单链的情况，但是无需旋转\(\text{rotate}\)，而是通过分裂\(\text{split}\)完成操作。其代码极度简洁，极度舒适，反正拯救了我的平衡树。

基本操作

\(\text{split}\)

分裂为左右两个子树\(x,y\)，子树\(x\)内的数均\(\le k\)，而子树\(y\)内的数$ >k\(。（这里是按权值分裂，还有一种按子树大小分裂的，即子树\)x\(大小为\)k$，维护区间翻转的时候需要用）

当前节点值\(\le k\)时，说明当前节点及其左子树肯定都是\(\le k\)，当前要找的\(x\)子树树根就是当前节点，而\(y\)子树树根不确定。而且对于其右子树是否均\(>k\)我们并不确定，因为可能右儿子的左子树中可能还有\(\le k\)的，所以我们还要递归找下去。

void split(int cur, int k, int &x, int &y){
	if(cur==0){x=y=0;return;}
	if(tre[cur].val<=k){
		x=cur;
		split(tre[cur].sr, k, tre[cur].sr, y); // 递归找其右儿子
	}else{
		y=cur;
		split(tre[cur].sl, k, x, tre[cur].sl); // 递归找其左儿子
	}
	update(cur); // 更新子树大小
}

\(\text{merge}\)

合并两个子树\(x,y\)，默认子树\(x\)均小于子树\(y\)中的数

合并子树的同时利用随机权值维护一个堆（这里是小根堆）。维护堆的同时维护\(\text{BST}\)，让小于等于自己的数成为左儿子，大于自己的数成为右儿子。

int merge(int x, int y){
	if(!x||!y) return x|y;
	if(tre[x].rnd<tre[y].rnd){
		tre[x].sr=merge(tre[x].sr, y);
		update(x);
		return x;
	}else{
		tre[y].sl=merge(x, tre[y].sl);
		update(y);
		return y;
	}
}

\(\text{new_nod}\)

新建一个节点并返回其编号。

inline int new_nod(int val){
	++tot;
	tre[tot].val=val;
	tre[tot].rnd=rand();
	tre[tot].sz=1;
	return tot;
}

\(\text{insert}\)

插入数值\(val\)

inline void insert(int val){
	split(root, val, x, y);
	root=merge(merge(x, new_nod(val)), y);
}

\(\text{del}\)

删除数值\(val\)

通过两次分裂子树，定位到全为\(val\)子树（节点）的位置，然后直接将这个全为\(val\)的子树直接删除。

inline void del(int val){
	split(root, val, x, z);
	split(x, val-1, x, y);
	y=merge(tre[y].sl, tre[y].sr);
	root=merge(merge(x,y), z);
}

\(\text{rank}\)

获取数值\(val\)的排名

inline int get_rank(int val){
	split(root, val-1, x, y);
	int res=tre[x].sz+1;
	root=merge(x,y);
	return res;
}

\(\text{kth}\)

获得第\(k\)大的数值

inline int get_kth(int cur, int k){
	while(1){
		if(k<=tre[tre[cur].sl].sz) cur=tre[cur].sl;
		else if(k==tre[tre[cur].sl].sz+1) return cur;
		else k-=tre[tre[cur].sl].sz+1, cur=tre[cur].sr;
	}
}

\(\text{pre}\)

前驱，注意存在多个\(val\)数值的情况

inline int get_pre(int val){
	split(root, val-1, x, y);
	int res=get_kth(x, tre[x].sz);
	root=merge(x,y);
	return res;
}

\(\text{nxt}\)

后驱

inline int get_nxt(int val){
	split(root, val, x, y);
	int res=get_kth(y, 1);
	root=merge(x,y);
	return res;
}

普通平衡树

1. 插入x数
2. 删除x数(若有多个相同的数，因只删除一个)
3. 查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x，且最大的数)
6. 求x的后继(后继定义为大于x，且最小的数)

完整代码：

#include <cstdio>
#include <cstdlib>
#define MAXN 100010
using namespace std;
struct nod{
	int sl,sr;
	int rnd,val,sz;
} tre[MAXN];
inline void update(int x){
	tre[x].sz=tre[tre[x].sl].sz+tre[tre[x].sr].sz+1;
}
int merge(int x, int y){
	if(!x||!y) return x|y;
	if(tre[x].rnd<tre[y].rnd){
		tre[x].sr=merge(tre[x].sr, y);
		update(x);
		return x;
	}else{
		tre[y].sl=merge(x, tre[y].sl);
		update(y);
		return y;
	}
}
void split(int cur, int k, int &x, int &y){
	if(cur==0){
		x=y=0;
		return;
	}
	if(tre[cur].val<=k){
		x=cur;
		split(tre[cur].sr, k, tre[cur].sr, y);
	}else{
		y=cur;
		split(tre[cur].sl, k, x, tre[cur].sl);
	}
	update(cur);
}
int tot,root,x,y,z;
inline int new_nod(int val){
	++tot;
	tre[tot].val=val;
	tre[tot].rnd=rand();
	tre[tot].sz=1;
	return tot;
}
inline void insert(int val){
	split(root, val, x, y);
	root=merge(merge(x, new_nod(val)), y);
}
inline void del(int val){
	split(root, val, x, z);
	split(x, val-1, x, y);
	y=merge(tre[y].sl, tre[y].sr);
	root=merge(merge(x,y), z);
}
inline int get_rank(int val){
	split(root, val-1, x, y);
	int res=tre[x].sz+1;
	root=merge(x,y);
	return res;
}
inline int get_kth(int cur, int k){
	while(1){
		if(k<=tre[tre[cur].sl].sz) cur=tre[cur].sl;
		else if(k==tre[tre[cur].sl].sz+1) return cur;
		else k-=tre[tre[cur].sl].sz+1, cur=tre[cur].sr;
	}
}
inline int get_pre(int val){
	split(root, val-1, x, y);
	int res=get_kth(x, tre[x].sz);
	root=merge(x,y);
	return res;
}
inline int get_nxt(int val){
	split(root, val, x, y);
	int res=get_kth(y, 1);
	root=merge(x,y);
	return res;
}
int t;
int main()
{
	srand((unsigned)19270817);
	scanf("%d", &t);
	while(t--){
		int opt,a;
		scanf("%d %d", &opt, &a);
		if(opt==1) insert(a);
		else if(opt==2) del(a);
		else if(opt==3) printf("%d\n", get_rank(a));
		else if(opt==4) printf("%d\n", tre[get_kth(root, a)].val);
		else if(opt==5) printf("%d\n", tre[get_pre(a)].val);
		else printf("%d\n", tre[get_nxt(a)].val);
	}
	return 0;
}

文艺平衡树

支持区间翻转，多次区间翻转，最后询问最终序列

这里我们就按树大小分裂子树，每次翻转区间\([l,r]\)时，通过两次分裂找出包含区间\([l,r]\)的树，然后用懒标记标记一下（\(change\)表示是否旋转当前树所代表的区间）。每次操作或查询前下放标记即可。

#include <cstdio>
#include <algorithm>
#include <cstdlib>
#define MAXN 100010
using namespace std;
struct nod{
    int l,r,val,rnd,sz;
    bool change;
} tre[MAXN];
int rot,tot;
inline void push_down(int x){
    swap(tre[x].l, tre[x].r);
    if(tre[x].l) tre[tre[x].l].change=!tre[tre[x].l].change;
    if(tre[x].r) tre[tre[x].r].change=!tre[tre[x].r].change;
    tre[x].change=0;
}
inline void update(int x){
    tre[x].sz=tre[tre[x].l].sz+tre[tre[x].r].sz+1;
}
inline int new_nod(int val){
	++tot;
	tre[tot].val=val;
	tre[tot].rnd=rand();
	tre[tot].sz=1;
	return tot;
}
int merge(int x, int y){
    if(x==0||y==0) return x|y;
    if(tre[x].rnd<tre[y].rnd){
        if(tre[x].change) push_down(x);
        tre[x].r=merge(tre[x].r, y);
        update(x);
        return x;
    }else{
        if(tre[y].change) push_down(y);
        tre[y].l=merge(x, tre[y].l);
        update(y);
        return y;
    }
}
void split(int cur, int k, int &x, int &y){
    if(!cur){x=y=0;return;}
    if(tre[cur].change) push_down(cur);
    if(tre[tre[cur].l].sz<k){
        x=cur;
        split(tre[cur].r, k-tre[tre[cur].l].sz-1, tre[cur].r, y);
    }else{
        y=cur;
        split(tre[cur].l, k, x, tre[cur].l);
    }
    update(cur);
}
void change(int l, int r){
    int x,y,z;
    split(rot,l-1,x,y);
    split(y,r-l+1,y,z);
    tre[y].change=!tre[y].change;
    rot=merge(merge(x,y),z);
}
void dfs(int x){
    if(!x) return;
    if(tre[x].change) push_down(x);
    dfs(tre[x].l);
    printf("%d ", tre[x].val);
    dfs(tre[x].r);
}
int n,m;
int main()
{
    srand((unsigned)19270817);
    scanf("%d %d", &n, &m);
    for(int i=1;i<=n;++i) rot=merge(rot, new_nod(i));
    while(m--){
        int l,r;
        scanf("%d %d", &l, &r);
        change(l, r);
    }
    dfs(rot);
    return 0;
}