FHQ-Treap（非旋 Treap）学习笔记

最新推荐文章于 2024-01-05 23:05:51 发布

wyy603

最新推荐文章于 2024-01-05 23:05:51 发布

阅读量595

点赞数

本文链接：https://blog.csdn.net/wyy603/article/details/106445447

版权

参考文章

FHQ-Treap 学习笔记

所以我这个学习笔记。。就是抄一遍？因为他讲的太清楚了！

那这篇学习笔记存在的意义是？学习笔记嘛，一方面也是写给自己看的。。

Treap

Treap = BST + Heap，什么意思？

一开始每个节点都具有一个权值 val，现在我们给每个节点都增加一个修正值 key，使得 Treap 在关注 val 时是 BST（二叉搜索树），在关注 key 时是 Heap（堆），这个堆需要满足每个节点严格小于所有子树里的儿子（也就是说这里是小根堆）。可以证明，给定一些点的集合，构成的 Treap 只可能有一个，且当 key 随机时树高期望 $O(\log n)$ 。

FHQ-Treap 的基本操作

FHQ-Treap 给出了一种不基于旋转的维护方法，其本质是依靠 Treap 的结构唯一性。

~~FHQ-Treap 我吹爆，实在是太好写了~~

分裂

有两种分裂方式，看具体要做什么问题。

按权值分裂

我们要做的事：给定一个 Treap，将其中所有节点按照是否小于等于 queryval 分类，分别分裂进两个不同的 Treap。

借用参考文章的一张图。。

我们动态维护两棵要造的 Treap 的虚点 x, y（这两个虚点也能表示这两棵 Treap 本身，故下文不会区分了）和原 Treap 上的点 now，通过判断 val[now] 与 queryval 的大小来判断左右子树的归属，并递归到儿子中继续分裂。

比如如果 val[now]<=queryval，那么{左子树+now}（也就是第2步中蓝色部分）都将归属 x，将这一部分拷过去后虚点 x 前往右儿子，now 也前往右儿子。

实现：

void split(int now, int k, int& x, int& y) { // 注意 x,y 是传址
	if (!now) { x = y = 0; return; }
	if (val[now] <= k) x = now, split(rs[now], k, rs[now], y); // x = now 是拷贝过去，递归进入下一层继续分裂
	else y = now, split(ls[now], k, x, ls[now]); // {右子树+now} 被拷贝到 y
	pushUp(now); // 上传信息，在下面【按排名分裂】会提到
}

按排名分裂

这里的排名指的是中序遍历（左中右）的排名。

功能：将排名 <= k 的放到 x 里，>k 的放到 y 里。

我们只需要算出 now 的 “val” 是多少，如果是按排名分裂，这个 “val” 就是 siz[ls[now]]+1 了。

那么首先我们需要维护每个点的子树大小 siz，这可以通过上传标记完成：

void pushUp(int x) { siz[x] = siz[ls[x]] + siz[rs[x]] + 1; }

接下来在写的时候我们需要关注什么时候加 pushUp，比如按排名分裂的实现：

void split(int now, int k, int& x, int& y) {
	if (!now) { x = y = 0; return; }
	if (siz[ls[now]] + 1 <= k) x = now, split(rs[now], k - siz[ls[now]] - 1, rs[now], y);
	else y = now, split(ls[now], k, x, ls[now]);
	pushUp(now);
}

合并

给两个 Treap 我们就合并这行不通的，但我们可以做的是：给定两个 Treap x, y 并保证 y 的所有点的 val 都大于等于 x 所有点的 val，将它们合并成一个 Treap。可以发现这个功能是随分裂而生的，因为分裂出来的两个 Treap 正好满足上述条件。

还是~~厚颜无耻地~~借用一下参考文章里的图。。

如图，我们沿用了上文分裂的例子，黑底白字是 val 权值，而白底黑字是 key 修正值。当一个节点被染蓝，说明此节点已被放入最终获得了主树内。（摘自参考文章）

我们要同时维护 val 的二叉树性质和 rnd 的小根堆性质。令 merge(x,y) （两个参数 x,y 既可以被理解为点，也可以被理解为它作为根所代表的 Treap）表示将 x,y 两棵 Treap 合并，返回合并后的根。可以确定的是根是 x,y 中的其中一个，所以我们比较 key 来判断谁是根。

int merge(int x, int y) { 
	if (!x || !y) return x + y;
	if (key[x] < key[y]) { rs[x] = merge(rs[x], y), pushUp(x); return x; } // 根是 x，y 肯定接在 rs[x] 里面。
	else { ls[y] = merge(x, ls[y]), pushUp(y); return y; } // 根是 y，x 肯定接在 ls[y] 里面。
}

那么 FHQ-Treap 最重要的两个操作就讲完了。

FHQ-Treap 维护集合操作 - 引例 [模板]普通平衡树

题意

链接

插入

我们将 Treap 分裂成 <=x 和 >x 的，然后新建一个权值为 x 的节点（也就是一棵大小为 1 的 Treap），将三者按序合并即可。

void insert(int x) { r1 = r2 = 0, split(root, x, r1, r2), root = merge(merge(r1, newnode(x)), r2); }

删除

我们将 Treap 分裂成三部分：<x，=x，>x，然后在 =x 中把根去掉（也就是把根的左右子合并），再将三部分合并即可。

void remove(int x) {
	r1 = r2 = r3 = 0, split(root, x, r1, r2), split(r1, x - 1, r1, r3); //r1(<x),r3(=x),r2(>x)
	r3 = merge(ls[r3], rs[r3]), root = merge(merge(r1, r3), r2);
}

求排名

我们将 Treap 分裂成 <x 和 >=x，直接查 <x 的大小就可。

int rnk(int x) {
	int ret = 0; r1 = r2 = 0, split(root, x - 1, r1, r2), ret = siz[r1] + 1, root = merge(r1, r2);
	return ret;
}

求第 k 大

按照正常的 BST 搜索即可。

int kth(int x, int k) {
	if (k <= siz[ls[x]]) return kth(ls[x], k);
	else if (k > siz[ls[x]] + 1) return kth(rs[x], k - siz[ls[x]] - 1);
	else return x;
}

求前驱 / 后继

前驱：将 Treap 分为两部分：<x，>=x，找到 <x 中最大的（也就是从根开始一直往右走）即可。

后继：同理。

int pre(int x) {
	split(root, x - 1, r1, r2); int p;
	for (p = r1; rs[p]; p = rs[p]);
	root = merge(r1, r2); return p;
}
int nex(int x) {
	split(root, x, r1, r2); int p;
	for (p = r2; ls[p]; p = ls[p]);
	root = merge(r1, r2); return p;
}

完整代码

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int MAXN = 100005;

int N, root, ls[MAXN], rs[MAXN], val[MAXN], key[MAXN], siz[MAXN], Tlen;
int newnode(int x) { ++Tlen, val[Tlen] = x, key[Tlen] = rand(), siz[Tlen] = 1; return Tlen; }
void pushUp(int x) { siz[x] = siz[ls[x]] + siz[rs[x]] + 1; }
void split(int now, int k, int& x, int& y) {
	if (!now) { x = y = 0; return; }
	if (val[now] <= k) x = now, split(rs[now], k, rs[now], y);
	else y = now, split(ls[now], k, x, ls[now]);
	pushUp(now);
}
int merge(int x, int y) {
	if (!x || !y) return x + y;
	if (key[x] > key[y]) { rs[x] = merge(rs[x], y), pushUp(x); return x; }
	else { ls[y] = merge(x, ls[y]), pushUp(y); return y; }
}
int r1, r2, r3;
void insert(int x) { r1 = r2 = 0, split(root, x, r1, r2), root = merge(merge(r1, newnode(x)), r2); }
void remove(int x) {
	r1 = r2 = r3 = 0, split(root, x, r1, r2), split(r1, x - 1, r1, r3), r3 = merge(ls[r3], rs[r3]), root = merge(merge(r1, r3), r2);
}
int rnk(int x) {
	int ret = 0; r1 = r2 = 0, split(root, x - 1, r1, r2), ret = siz[r1] + 1, root = merge(r1, r2);
	return ret;
}
int kth(int x, int k) {
	if (k <= siz[ls[x]]) return kth(ls[x], k);
	else if (k > siz[ls[x]] + 1) return kth(rs[x], k - siz[ls[x]] - 1);
	else return x;
}
int pre(int x) {
	split(root, x - 1, r1, r2); int p;
	for (p = r1; rs[p]; p = rs[p]);
	root = merge(r1, r2); return p;
}
int nex(int x) {
	split(root, x, r1, r2); int p;
	for (p = r2; ls[p]; p = ls[p]);
	root = merge(r1, r2); return p;
}

int main() {
	scanf("%d", &N); int op, x;
	srand(19260817);
	for (int i = 1; i <= N; ++i) {
		scanf("%d%d", &op, &x);
		if (op == 1) insert(x);
		else if (op == 2) remove(x);
		else if (op == 3) printf("%d\n", rnk(x));
		else if (op == 4) printf("%d\n", val[kth(root, x)]);
		else if (op == 5) printf("%d\n", val[pre(x)]);
		else if (op == 6) printf("%d\n", val[nex(x)]);
	}
	return 0;
}

FHQ-Treap 维护区间操作 - 引例 [模板]文艺平衡树

题意

链接

怎么维护

我们令 Treap 表示的序列是它的中序遍历所构成的序列。

如果我们要求区间和，我们只需要将 Treap 按排名把 l<=排名<=r 这一部分分出来，然后求区间和（在每个点上维护区间和的值然后 pushup）

如果我们要输出整个序列，我们只需要跑中序遍历。

如果我们要插入，我们只需要用上面【维护集合操作】中的插入方法来插入。

懒惰标记

但这题的翻转操作怎么维护？使用懒惰标记。

但这已经在线段树给讲透了？所以好像也没啥可讲的。

完整代码

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100005;
int N, M, root, ls[MAXN], rs[MAXN], val[MAXN], key[MAXN], siz[MAXN], tag[MAXN], Tlen;
int newnode(int x) { ++Tlen, val[Tlen] = x, key[Tlen] = rand(), siz[Tlen] = 1; return Tlen; }
void pushUp(int x) { siz[x] = siz[ls[x]] + siz[rs[x]] + 1; }
void cover(int x) { tag[x] ^= 1, swap(ls[x], rs[x]); }
void pushDown(int x) { if (tag[x]) cover(ls[x]), cover(rs[x]), tag[x] = 0; }
void split(int now, int k, int& x, int& y) {
	if (!now) { x = y = 0; return; }
	pushDown(now);
	if (siz[ls[now]] + 1 <= k) x = now, split(rs[now], k - siz[ls[now]] - 1, rs[now], y);
	else y = now, split(ls[now], k, x, ls[now]);
	pushUp(now);
}
int merge(int x, int y) {
	if (!x || !y) return x + y;
	pushDown(x), pushDown(y);
	if (key[x] < key[y]) { ls[y] = merge(x, ls[y]), pushUp(y); return y; }
	else { rs[x] = merge(rs[x], y), pushUp(x); return x; }
}
void modify(int l, int r) {
	int r1 = 0, r2 = 0, r3 = 0;
	split(root, r, r1, r2), split(r1, l - 1, r1, r3), cover(r3);
	root = merge(merge(r1, r3), r2);
}
void dfs(int x) {
	pushDown(x);
	if (ls[x]) dfs(ls[x]);
	printf("%d ", val[x]);
	if (rs[x]) dfs(rs[x]);
}

int main() {
	scanf("%d%d", &N, &M); int l, r;
	srand(19260817);
	for (int i = 1; i <= N; ++i) root = merge(root, newnode(i));
	while (M--) {
		scanf("%d%d", &l, &r), modify(l, r);
	}
	dfs(root);
	return 0;
}

例题

[BJOI2017] 喷施水战改

wyy603

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
FHQ-Treap（非旋 Treap）学习笔记

参考文章FHQ-Treap 学习笔记所以我这个学习笔记。。就是抄一遍？因为他讲的太清楚了！那这篇学习笔记存在的意义是？学习笔记嘛，一方面也是写给自己看的。。TreapTreap = BST + Heap，什么意思？一开始每个节点都具有一个权值 val，现在我们给每个节点都增加一个修正值 key，使得 Treap 在关注 val 时是 BST（二叉搜索树），在关注 key 时是 Heap（堆），这个堆需要满足每个节点严格小于所有子树里的儿子（也就是说这里是小根堆）。可以证明，给定一些点的集合，构成
复制链接

扫一扫