FHQ-treap，即无旋 treap，又称分裂合并 treap，支持维护序列，可持久化等特性。

FHQ-treap 有两个核心操作，分裂 与 合并。通过这两个操作，在很多情况下可以比旋转 treap 等方便的实现一些操作。

FHQ-treap 与其他的平衡树相比，他最明显的优点是：它好写！！！，想象一下，在考场上，你用较短的时间写出 FHQ-treap 和花很长时间敲 Splay，还得琢磨到底怎么旋转，优势就体现的很明显了，它和 treap 相比，它可以更好的进行区间操作，接下来将一一介绍。

平衡树也是一棵二叉搜索树。

结构体定义

定义

这里我们采取结构体来定义平衡树的节点，下面是最基本的节点信息。

  1. struct node {
  2. 	int val, pai, siz;
  3. 	int ls, rs;
  4. } t[N];

pai 是我们随机的一个值，val 是当前节点的权值，ls, rs 左右孩子，siz 是当前点的子树大小。

增加新节点

为了节省空间，我们一般会开一个“垃圾桶”来存储被删掉的节点的编号，要增加新节点时，如果垃圾桶里有节点，那么优先使用垃圾桶里的节点。回收利用很环保

  1. vector<int> rub;
  2. int newnod(int x) {
  3. 	int u;
  4. 	if (!rub.empty()) {
  5. 		u = rub.back();
  6. 		rub.pop_back();
  7. 	}
  8. 	else {
  9. 		u = ++ tot;
  10. 	}
  11. 	t[u].siz = 1;
  12. 	t[u].ls = t[u].rs = 0;
  13. 	t[u].val = x;
  14. 	t[u].pai = rand();
  15. 	return u;
  16. }

分裂

分裂有两种，一种是按照节点个数来分裂，另一种是按照权值大小来分裂。

一般最常用的是按照节点个数分裂，但是按照权值大小分裂也会用到。

一般进行操作，我们的通用方法是将被操作点单独分裂成一棵树，对这棵树进行操作。

按照节点数量分裂的代码。

  1. void split_rk(int u, int k, int &x, int &y) {
  2. 	if (u == 0) {
  3. 		x = y = 0;
  4. 		return ;
  5. 	}
  6. 	if (t[lc].siz + 1 <= k) {
  7. 		x = u;
  8. 		split_rk(rc, k - t[lc].siz - 1, t[u].rs, y);
  9. 	}
  10. 	else {
  11. 		y = u;
  12. 		split_rk(lc, k, x, t[u].ls);
  13. 	}
  14. 	pushup(u);
  15. }

按照权值分裂的代码。

  1. void split_val(int u, int v, int &x, int &y) { // x 和 y 是传参类型
  2. 	if (u == 0) {
  3. 		x = y = 0;
  4. 		return ;
  5. 	}
  6. 	if (t[u].val <= v) {
  7. 		x = u;
  8. 		split_val(rc, v, rc, y);
  9. 	}
  10. 	else {
  11. 		y = u;
  12. 		split_val(lc, v, x, lc);
  13. 	}
  14. 	pushup(u);
  15. }

合并

在旋转 treap 中，我们借助旋转操作来维护堆的性质，同时旋转时还不能改变树的性质。在无旋 treap 中，我们用合并达到相同的效果。

因为两个 treap 已经有序，所以我们在合并的时候只需要考虑把哪个树「放在上面」，把哪个「放在下面」，也就是是需要判断将哪个一个树作为子树。显然，根据堆的性质，我们需要把 \(pai\) 小的放在上面（这里采用小根堆）。

同时，我们还需要满足搜索树的性质。设 \(u < v\)，若 \(u\) 的 \(pai\) 小于 \(v\) 的，那么 \(u\) 即为新根结点，并且 \(v\) 因为值比 \(u\) 更大，应与 \(u\) 的右子树合并；反之，则 \(v\) 作为新根结点，然后因为 \(u\) 的值比 \(v\) 小，与 \(v\) 的左子树合并。

  1. int Merge(int x, int y) {
  2. 	if (!x || !y) {
  3. 		return x + y;
  4. 	}
  5. 	if (t[x].pai < t[y].pai) {
  6. 		t[x].rs = Merge(t[x].rs, y);
  7. 		pushup(x);
  8. 		return x;
  9. 	}
  10. 	else {
  11. 		t[y].ls = Merge(x, t[y].ls);
  12. 		pushup(y);
  13. 		return y;
  14. 	}
  15. }

基本操作

插入

将新节点要插入的位置分裂出来，然后合并即可。

  1. void Insert(int x) {
  2. 	int u = newnod(x);
  3. 	int t1, t2;
  4. 	split_val(rt, x, t1, t2);
  5. 	rt = Merge(Merge(t1, u), t2);
  6. }

删除

将要删除的节点分裂出来，将两边的子树合并即可。

  1. void Erase(int x) {
  2. 	int t1, t2, t3;
  3. 	split_val(rt, x - 1, t1, t2);
  4. 	split_val(t2, x, t2, t3);
  5. 	rub.emplace_back(t2);
  6. 	t2 = Merge(t[t2].ls, t[t2].rs);
  7. 	rt = Merge(Merge(t1, t2), t3);
  8. }

查找排名

将要查找的点按照权值分裂出来，前面分裂出去的树的大小 \(+ 1\) 就是排名。

  1. int getrank(int x) {
  2. 	int t1, t2, rk;
  3. 	split_val(rt, x - 1, t1, t2);
  4. 	rk = t[t1].siz + 1;
  5. 	rt = Merge(t1, t2);
  6. 	ans ^= rk;
  7. 	las = rk;
  8. 	return rk;
  9. }

查找排名为 \(x\) 的节点的权值

将要查找的点按照节点个数分裂出来，进行操作。

  1. int getval(int x) {
  2. 	int t1, t2, t3, val;
  3. 	split_rk(rt, x - 1, t1, t2);
  4. 	split_rk(t2, 1, t2, t3);
  5. 	val = t[t2].val;
  6. 	ans ^= val;
  7. 	las = val;
  8. 	Merge(Merge(t1, t2), t3);
  9. 	return val;
  10. }

查找前驱后继

利用分裂来查找。

  1. int pre(int x) {
  2. 	int t1, t2, t3, pre;
  3. 	split_val(rt, x - 1, t1, t2);
  4. 	split_rk(t1, t[t1].siz - 1, t1, t3);
  5. 	pre = t[t3].val;
  6. 	rt = Merge(Merge(t1, t3), t2);
  7. 	ans ^= pre;
  8. 	las = pre;
  9. 	return pre;
  10. }
  12. int nxt(int x) {
  13. 	int t1, t2, t3, nxt;
  14. 	split_val(rt, x, t1, t2);
  15. 	split_rk(t2, 1, t2, t3);
  16. 	nxt = t[t2].val;
  17. 	rt = Merge(Merge(t1, t2), t3);
  18. 	ans ^= nxt;
  19. 	las = nxt;
  20. 	return nxt;
  21. }

区间操作

P3391 【模板】文艺平衡树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

区间翻转练习题

  1. /*
  2.   The code was written by yifan, and yifan is neutral!!!
  3.  */
  5. #include <bits/stdc++.h>
  6. using namespace std;
  7. typedef long long ll;
  8. #define lc t[u].ls
  9. #define rc t[u].rs
  11. template<typename T>
  12. inline T read() {
  13. 	T x = 0;
  14. 	bool fg = 0;
  15. 	char ch = getchar();
  16. 	while (ch < '0' || ch > '9') {
  17. 		fg |= (ch == '-');
  18. 		ch = getchar();
  19. 	}
  20. 	while (ch >= '0' && ch <= '9') {
  21. 		x = (x << 3) + (x << 1) + (ch ^ 48);
  22. 		ch = getchar();
  23. 	}
  24. 	return fg ? ~x + 1 : x;
  25. }
  27. const int N = 1e5 + 5;
  29. int n, m, rt, tot;
  30. vector<int> rub;
  32. struct node {
  33. 	int val, tag;
  34. 	int ls, rs, siz, pai;
  35. } t[N << 1];
  37. inline void pushup(int u) {
  38. 	t[u].siz = t[lc].siz + t[rc].siz + 1;
  39. }
  41. inline void pushdown(int u) {
  42. 	if (!t[u].tag) {
  43. 		return ;
  44. 	}
  45. 	if (lc)	t[lc].tag ^= 1;
  46. 	if (rc)	t[rc].tag ^= 1;
  47. 	swap(t[u].ls, t[u].rs);
  48. 	t[u].tag = 0;
  49. }
  51. int newnod(int x) {
  52. 	int u = ++ tot;
  53. 	t[u].siz = 1;
  54. 	t[u].ls = t[u].rs = t[u].tag = 0;
  55. 	t[u].val = x;
  56. 	t[u].pai = rand();
  57. 	return u;
  58. }
  60. void split_rk(int u, int k, int &x, int &y) {
  61. 	if (!u) {
  62. 		x = y = 0;
  63. 		return ;
  64. 	}
  65. 	pushdown(u);
  66. 	if (t[lc].siz + 1 <= k) {
  67. 		x = u;
  68. 		split_rk(rc, k - t[lc].siz - 1, rc, y);
  69. 	}
  70. 	else {
  71. 		y = u;
  72. 		split_rk(lc, k, x, lc);
  73. 	}
  74. 	pushup(u);
  75. }
  77. int Merge(int x, int y) {
  78. 	if (!x || !y) {
  79. 		return x + y;
  80. 	}
  81. 	if (t[x].pai < t[y].pai) {
  82. 		pushdown(x);
  83. 		t[x].rs = Merge(t[x].rs, y);
  84. 		pushup(x);
  85. 		return x;
  86. 	}
  87. 	else {
  88. 		pushdown(y);
  89. 		t[y].ls = Merge(x, t[y].ls);
  90. 		pushup(y);
  91. 		return y;
  92. 	}
  93. }
  95. void print(int u) {
  96. 	if (!u)	return ;
  97. 	pushdown(u);
  98. 	print(t[u].ls);
  99. 	printf("%d ", t[u].val);
  100. 	print(t[u].rs);
  101. }
  103. int main() {
  104. 	srand(time(NULL));
  105. 	n = read<int>(), m = read<int>();
  106. 	for (int i = 1; i <= n; ++ i) {
  107. 		rt = Merge(rt, newnod(i));
  108. 	}
  109. 	for (int i = 1, l, r; i <= m; ++ i) {
  110. 		l = read<int>(), r = read<int>();
  111. 		int t1, t2, t3;
  112. 		split_rk(rt, l - 1, t1, t2);
  113. 		split_rk(t2, r - l + 1, t2, t3);
  114. 		t[t2].tag ^= 1;
  115. 		rt = Merge(t1, Merge(t2, t3));
  116. 	}
  117. 	print(rt);
  118. 	return 0;
  119. }

P2042 [NOI2005] 维护数列 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

区间操作的练习好题，涉及线段树操作。

  1. /*
  2.   The code was written by yifan, and yifan is neutral!!!
  3.  */
  5. #include <bits/stdc++.h>
  6. using namespace std;
  7. typedef long long ll;
  8. #define lc (t[u].ls)
  9. #define rc (t[u].rs)
  11. template<typename T>
  12. inline T read() {
  13. 	T x = 0;
  14. 	bool fg = 0;
  15. 	char ch = getchar();
  16. 	while (ch < '0' || ch > '9') {
  17. 		fg |= (ch == '-');
  18. 		ch = getchar();
  19. 	}
  20. 	while (ch >= '0' && ch <= '9') {
  21. 		x = (x << 3) + (x << 1) + (ch ^ 48);
  22. 		ch = getchar();
  23. 	}
  24. 	return fg ? ~x + 1 : x;
  25. }
  27. const int N = 1e6 + 6;
  28. mt19937 rnd(time(0));
  30. int n, m, tot, rt;
  31. int a[N];
  32. vector<int> rub;
  34. struct node {
  35. 	int pai, ls, rs, siz;
  36. 	ll val, sum, mx, maxpre, maxlas, tag;
  37. 	bool tag1, tag2;
  38. } t[N];
  40. int New(int x) {
  41. 	int u;
  42. 	if (!rub.empty()) {
  43. 		u = rub.back();
  44. 		rub.pop_back();
  45. 	} else {
  46. 		u = ++ tot;
  47. 	}
  48. 	t[u].sum = t[u].val = (t[u].mx = x);
  49. 	t[u].maxpre = t[u].maxlas = max(0, x);
  50. 	t[u].siz = 1;
  51. 	t[u].pai = rnd();
  52. 	t[u].tag1 = t[u].tag2 = (t[u].tag = 0);
  53. 	t[u].ls = t[u].rs = 0;
  54. 	return u;
  55. }
  57. void pushup(int u) {
  58. 	if (!u) return;
  59. 	t[u].siz = t[lc].siz + t[rc].siz + 1;
  60. 	t[u].sum = t[lc].sum + t[rc].sum + t[u].val;
  61. 	t[u].maxpre = max(max(t[lc].maxpre, t[lc].sum + t[u].val + t[rc].maxpre), 0ll);
  62. 	t[u].maxlas = max(max(t[rc].maxlas, t[rc].sum + t[u].val + t[lc].maxlas), 0ll);
  63. 	t[u].mx = max(0ll, t[lc].maxlas + t[rc].maxpre) + t[u].val;
  64. 	if (lc) t[u].mx = max(t[u].mx, t[lc].mx);
  65. 	if (rc) t[u].mx = max(t[u].mx, t[rc].mx);
  66. }
  68. void cover(int u, ll c) {
  69. 	t[u].val = t[u].tag = c;
  70. 	t[u].sum = t[u].siz * c;
  71. 	t[u].maxpre = t[u].maxlas = max(0ll, t[u].sum);
  72. 	t[u].mx = max(c, t[u].sum);
  73. 	t[u].tag1 = 1;
  74. }
  76. void Reverse(int u) {
  77. 	if (!u)	return ;
  78. 	swap(lc, rc);
  79. 	swap(t[u].maxpre, t[u].maxlas);
  80. 	t[u].tag2 ^= 1;
  81. }
  83. void pushdown(int u) {
  84. 	if (!u)	return ;
  85. 	if (t[u].tag2) {
  86. 		if (lc) {
  87. 			Reverse(lc);
  88. 		}
  89. 		if (rc) {
  90. 			Reverse(rc);
  91. 		}
  92. 		t[u].tag2 = 0;
  93. 	}
  94. 	if (t[u].tag1) {
  95. 		if (lc) {
  96. 			cover(lc, t[u].tag);
  97. 		}
  98. 		if (rc) {
  99. 			cover(rc, t[u].tag);
  100. 		}
  101. 		t[u].tag = t[u].tag1 = 0;
  102. 	}
  103. }
  105. void split(int u, int k, int &x, int &y) {
  106. 	if (!u) {
  107. 		x = y = 0;
  108. 		return;
  109. 	}
  110. 	pushdown(u);
  111. 	if (t[lc].siz < k) {
  112. 		x = u;
  113. 		split(rc, k - t[lc].siz - 1, rc, y);
  114. 	} else {
  115. 		y = u;
  116. 		split(lc, k, x, lc);
  117. 	}
  118. 	pushup(u);
  119. }
  121. int Merge(int x, int y) {
  122. 	if (!x || !y) {
  123. 		return x + y;
  124. 	}
  125. 	if (t[x].pai < t[y].pai) {
  126. 		pushdown(x);
  127. 		t[x].rs = Merge(t[x].rs, y);
  128. 		pushup(x);
  129. 		return x;
  130. 	} else {
  131. 		pushdown(y);
  132. 		t[y].ls = Merge(x, t[y].ls);
  133. 		pushup(y);
  134. 		return y;
  135. 	}
  136. }
  138. int add(int l, int r) {
  139. 	if (l != r) {
  140. 		int mid = (l + r) >> 1;
  141. 		return Merge(add(l, mid), add(mid + 1, r));
  142. 	}
  143. 	return New(a[l]);
  144. }
  146. void Erase(int u) {
  147. 	if (!u)	return ;
  148. 	rub.emplace_back(u);
  149. 	if (lc) {
  150. 		Erase(lc);
  151. 	}
  152. 	if (rc) {
  153. 		Erase(rc);
  154. 	}
  155. }
  157. void print(int u) {
  158. 	if (!u)	return ;
  159. 	pushdown(u);
  160. 	print(lc);
  161. 	print(rc);
  162. }
  164. int main() {
  165. 	n = read<int>(), m = read<int>();
  166. 	for (int i = 1; i <= n; ++ i) {
  167. 		a[i] = read<int>();
  168. 	}
  169. 	rt = Merge(rt, add(1, n));
  170. 	string op;
  171. 	for (int i = 1, t1, t2, t3; i <= m; ++ i) {
  172. 		cin >> op;
  173. 		if (op == "INSERT") {
  174. 			int pos = read<int>(), len = read<int>();
  175. 			split(rt, pos, t1, t2);
  176. 			for (int i = 1; i <= len; ++ i) {
  177. 				a[i] = read<int>();
  178. 			}
  179. 			rt = Merge(Merge(t1, add(1, len)), t2);
  180. 		}
  181. 		if (op == "DELETE") {
  182. 			int pos = read<int>(), len = read<int>();
  183. 			split(rt, pos - 1, t1, t2);
  184. 			split(t2, len, t2, t3);
  185. 			Erase(t2);
  186. 			rt = Merge(t1, t3);
  187. 		}
  188. 		if (op == "MAKE-SAME") {
  189. 			int pos = read<int>(), len = read<int>(), v = read<int>();
  190. 			split(rt, pos - 1, t1, t2);
  191. 			split(t2, len, t2, t3);
  192. 			cover(t2, v);
  193. 			rt = Merge(Merge(t1, t2), t3);
  194. 		}
  195. 		if (op == "REVERSE") {
  196. 			int pos = read<int>(), len = read<int>();
  197. 			split(rt, pos - 1, t1, t2);
  198. 			split(t2, len, t2, t3);
  199. 			Reverse(t2);
  200. 			rt = Merge(Merge(t1, t2), t3);
  201. 		}
  202. 		if (op == "GET-SUM") {
  203. 			int pos = read<int>(), len = read<int>();
  204. 			split(rt, pos - 1, t1, t2);
  205. 			split(t2, len, t2, t3);
  206. 			printf("%lld\n", t[t2].sum);
  207. 			rt = Merge(Merge(t1, t2), t3);
  208. 		}
  209. 		if (op == "MAX-SUM") {
  210. 			printf("%lld\n", t[rt].mx);
  211. 		}
  212. 	}
  213. 	return 0;
  214. }

P2596 [ZJOI2006] 书架 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

模板题

  1. /*
  2.   The code was written by yifan, and yifan is neutral!!!
  3.  */
  5. #include <bits/stdc++.h>
  6. using namespace std;
  7. typedef long long ll;
  8. #define lc t[u].ls
  9. #define rc t[u].rs
  11. template<typename T>
  12. inline T read() {
  13. 	T x = 0;
  14. 	bool fg = 0;
  15. 	char ch = getchar();
  16. 	while (ch < '0' || ch > '9') {
  17. 		fg |= (ch == '-');
  18. 		ch = getchar();
  19. 	}
  20. 	while (ch >= '0' && ch <= '9') {
  21. 		x = (x << 3) + (x << 1) + (ch ^ 48);
  22. 		ch = getchar();
  23. 	}
  24. 	return fg ? ~x + 1 : x;
  25. }
  27. const int N = 8e4 + 5;
  29. mt19937 rnd(time(0));
  31. int n, m, tot, rt;
  32. int Id[N];
  34. struct node {
  35. 	int val, siz, pai;
  36. 	int ls, rs, fa;
  37. } t[N << 1];
  39. void pushup(int u) {
  40. 	t[u].siz = t[lc].siz + t[rc].siz + 1;
  41. 	t[lc].fa = t[rc].fa = u;
  42. }
  44. int New(int x) {
  45. 	int u = ++ tot;
  46. 	t[u].siz = 1;
  47. 	t[u].val = x;
  48. 	t[u].pai = rnd();
  49. 	t[u].ls = t[u].rs = t[u].fa = 0;
  50. 	Id[x] = u;
  51. 	return u;
  52. }
  54. int Find(int u) {
  55. 	int res = t[t[u].ls].siz + 1;
  56. 	for (; u != rt; u = t[u].fa) {
  57. 		if (t[t[u].fa].rs == u) {
  58. 			res += t[t[t[u].fa].ls].siz + 1;
  59. 		}
  60. 	}
  61. 	return res;
  62. }
  64. void split_rk(int u, int k, int &x, int &y) {
  65. 	if (!u) {
  66. 		x = y = 0;
  67. 		return ;
  68. 	}
  69. 	if (t[lc].siz < k) {
  70. 		x = u;
  71. 		split_rk(rc, k - t[lc].siz - 1, rc, y);
  72. 	} else {
  73. 		y = u;
  74. 		split_rk(lc, k, x, lc);
  75. 	}
  76. 	pushup(u);
  77. }
  79. int Merge(int x, int y) {
  80. 	if (!x || !y) {
  81. 		return x + y;
  82. 	}
  83. 	if (t[x].pai < t[y].pai) {
  84. 		t[x].rs = Merge(t[x].rs, y);
  85. 		pushup(x);
  86. 		return x;
  87. 	} else {
  88. 		t[y].ls = Merge(x, t[y].ls);
  89. 		pushup(y);
  90. 		return y;
  91. 	}
  92. }
  94. int main() {
  95. 	n = read<int>(), m = read<int>();
  96. 	for (int i = 1; i <= n; ++ i) {
  97. 		rt = Merge(rt, New(read<int>()));
  98. 	}
  99. 	for (int i = 1, x, t1, t2, t3, t4; i <= m; ++ i) {
  100. 		string op;
  101. 		cin >> op;
  102. 		x = read<int>();
  103. 		if (op == "Top") {
  104. 			int k = Find(Id[x]);
  105. 			split_rk(rt, k - 1, t1, t2);
  106. 			split_rk(t2, 1, t2, t3);
  107. 			rt = Merge(Merge(t2, t1), t3);
  108. 		}
  109. 		if (op == "Bottom") {
  110. 			int k = Find(Id[x]);
  111. 			split_rk(rt, k - 1, t1, t2);
  112. 			split_rk(t2, 1, t2, t3);
  113. 			rt = Merge(Merge(t1, t3), t2);
  114. 		}
  115. 		if (op == "Insert") {
  116. 			int y = read<int>();
  117. 			int k = Find(Id[x]);
  118. 			if (y > 0) {
  119. 				split_rk(rt, k - 1, t1, t2);
  120. 				split_rk(t2, 1, t2, t3);
  121. 				split_rk(t3, y, t3, t4);
  122. 				rt = Merge(Merge(t1, t3), Merge(t2, t4));
  123. 			} else {
  124. 				split_rk(rt, k - 1, t1, t2);
  125. 				split_rk(t2, 1, t2, t3);
  126. 				split_rk(t1, k + y - 1, t1, t4);
  127. 				rt = Merge(Merge(t1, t2), Merge(t4, t3));
  128. 			}
  129. 		}
  130. 		if (op == "Ask") {
  131. 			cout << Find(Id[x]) - 1 << '\n';
  132. 		}
  133. 		if (op == "Query") {
  134. 			split_rk(rt, x - 1, t1, t2);
  135. 			split_rk(t2, 1, t2, t3);
  136. 			cout << t[t2].val << '\n';
  137. 			rt = Merge(Merge(t1, t2), t3);
  138. 		}
  139. 	}
  140. 	return 0;
  141. }

P3369 【模板】普通平衡树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

  1. /*
  2.   The code was written by yifan, and yifan is neutral!!!
  3.  */
  5. #include <bits/stdc++.h>
  6. using namespace std;
  7. typedef long long ll;
  8. #define lc t[u].ls
  9. #define rc t[u].rs
  11. template<typename T>
  12. inline T read() {
  13. 	T x = 0;
  14. 	bool fg = 0;
  15. 	char ch = getchar();
  16. 	while (ch < '0' || ch > '9') {
  17. 		fg |= (ch == '-');
  18. 		ch = getchar();
  19. 	}
  20. 	while (ch >= '0' && ch <= '9') {
  21. 		x = (x << 3) + (x << 1) + (ch ^ 48);
  22. 		ch = getchar();
  23. 	}
  24. 	return fg ? ~x + 1 : x;
  25. }
  27. const int N = 2e5 + 5;
  29. int n, tot, top, rt;
  30. vector<int> rub;
  32. struct node {
  33. 	int val, pai, siz;
  34. 	int ls, rs;
  35. } t[N];
  37. inline int newnod(int x) {
  38. 	int u;
  39. 	if (!rub.empty()) {
  40. 		u = rub.back();
  41. 		rub.pop_back();
  42. 	}
  43. 	else {
  44. 		u = ++ tot;
  45. 	}
  46. 	t[u].siz = 1;
  47. 	t[u].ls = t[u].rs = 0;
  48. 	t[u].val = x;
  49. 	t[u].pai = rand();
  50. 	return u;
  51. }
  53. inline void pushup(int u) {
  54. 	t[u].siz = t[lc].siz + 1 + t[rc].siz;
  55. }
  57. void split_rk(int u, int k, int &x, int &y) {
  58. 	if (u == 0) {
  59. 		x = y = 0;
  60. 		return ;
  61. 	}
  62. 	if (t[lc].siz + 1 <= k) {
  63. 		x = u;
  64. 		split_rk(rc, k - t[lc].siz - 1, t[u].rs, y);
  65. 	}
  66. 	else {
  67. 		y = u;
  68. 		split_rk(lc, k, x, t[u].ls);
  69. 	}
  70. 	pushup(u);
  71. }
  73. void split_val(int u, int v, int &x, int &y) {
  74. 	if (u == 0) {
  75. 		x = y = 0;
  76. 		return ;
  77. 	}
  78. 	if (t[u].val <= v) {
  79. 		x = u;
  80. 		split_val(rc, v, rc, y);
  81. 	}
  82. 	else {
  83. 		y = u;
  84. 		split_val(lc, v, x, lc);
  85. 	}
  86. 	pushup(u);
  87. }
  89. int Merge(int x, int y) {
  90. 	if (!x || !y) {
  91. 		return x + y;
  92. 	}
  93. 	if (t[x].pai < t[y].pai) {
  94. 		t[x].rs = Merge(t[x].rs, y);
  95. 		pushup(x);
  96. 		return x;
  97. 	}
  98. 	else {
  99. 		t[y].ls = Merge(x, t[y].ls);
  100. 		pushup(y);
  101. 		return y;
  102. 	}
  103. }
  105. inline void Insert(int x) {
  106. 	int u = newnod(x);
  107. 	int t1, t2;
  108. 	split_val(rt, x, t1, t2);
  109. 	rt = Merge(Merge(t1, u), t2);
  110. }
  112. inline void Erase(int x) {
  113. 	int t1, t2, t3;
  114. 	split_val(rt, x - 1, t1, t2);
  115. 	split_val(t2, x, t2, t3);
  116. 	rub.emplace_back(t2);
  117. 	t2 = Merge(t[t2].ls, t[t2].rs);
  118. 	rt = Merge(Merge(t1, t2), t3);
  119. }
  121. inline int getrank(int x) {
  122. 	int t1, t2, rk;
  123. 	split_val(rt, x - 1, t1, t2);
  124. 	rk = t[t1].siz + 1;
  125. 	rt = Merge(t1, t2);
  126. 	return rk;
  127. }
  129. inline int getval(int x) {
  130. 	int t1, t2, t3, val;
  131. 	split_rk(rt, x - 1, t1, t2);
  132. 	split_rk(t2, 1, t2, t3);
  133. 	val = t[t2].val;
  134. 	Merge(Merge(t1, t2), t3);
  135. 	return val;
  136. }
  138. inline int pre(int x) {
  139. 	int t1, t2, t3, pre;
  140. 	split_val(rt, x - 1, t1, t2);
  141. 	split_rk(t1, t[t1].siz - 1, t1, t3);
  142. 	pre = t[t3].val;
  143. 	rt = Merge(Merge(t1, t3), t2);
  144. 	return pre;
  145. }
  147. inline int las(int x) {
  148. 	int t1, t2, t3, las;
  149. 	split_val(rt, x, t1, t2);
  150. 	split_rk(t2, 1, t2, t3);
  151. 	las = t[t2].val;
  152. 	rt = Merge(Merge(t1, t2), t3);
  153. 	return las;
  154. }
  156. int main() {
  157. 	n = read<int>();
  158. 	for (int i = 1, x, op; i <= n; ++ i) {
  159. 		op = read<int>(), x = read<int>();
  160. 		switch(op) {
  161. 		case 1 :
  162. 			Insert(x);
  163. 			break ;
  164. 		case 2 :
  165. 			Erase(x);
  166. 			break ;
  167. 		case 3 :
  168. 			printf("%d\n", getrank(x));
  169. 			break ;
  170. 		case 4 :
  171. 			printf("%d\n", getval(x));
  172. 			break ;
  173. 		case 5 :
  174. 			printf("%d\n", pre(x));
  175. 			break ;
  176. 		case 6 :
  177. 			printf("%d\n", las(x));
  178. 			break ;
  179. 		}
  180. 	}
  181. 	return 0;
  182. }

「学习笔记」FHQ-treap的更多相关文章

  1. 「学习笔记」 FHQ Treap

    FHQ Treap FHQ Treap (%%%发明者范浩强年年NOI金牌)是一种神奇的数据结构,也叫非旋Treap,它不像Treap zig zag搞不清楚(所以叫非旋嘛),也不像Splay完全看不 ...

  2. 「学习笔记」Treap

    「学习笔记」Treap 前言 什么是 Treap ? 二叉搜索树 (Binary Search Tree/Binary Sort Tree/BST) 基础定义 查找元素 插入元素 删除元素 查找后继 ...

  3. 「学习笔记」平衡树基础：Splay 和 Treap

    「学习笔记」平衡树基础:Splay 和 Treap 点击查看目录 目录 「学习笔记」平衡树基础:Splay 和 Treap 知识点 平衡树概述 Splay 旋转操作 Splay 操作 插入 \(x\) ...

  4. 「学习笔记」Min25筛

    「学习笔记」Min25筛 前言 周指导今天模拟赛五分钟秒第一题,十分钟说第二题是 \(\text{Min25}​\) 筛板子题,要不是第三题出题人数据范围给错了,周指导十五分钟就 \(\text{AK ...

  5. 「学习笔记」FFT 之优化——NTT

    目录 「学习笔记」FFT 之优化--NTT 前言 引入 快速数论变换--NTT 一些引申问题及解决方法 三模数 NTT 拆系数 FFT (MTT) 「学习笔记」FFT 之优化--NTT 前言 \(NT ...

  6. 「学习笔记」FFT 快速傅里叶变换

    目录 「学习笔记」FFT 快速傅里叶变换 啥是 FFT 呀?它可以干什么? 必备芝士 点值表示 复数 傅立叶正变换 傅里叶逆变换 FFT 的代码实现 还会有的 NTT 和三模数 NTT... 「学习笔 ...

  7. 「学习笔记」字符串基础：Hash，KMP与Trie

    「学习笔记」字符串基础:Hash,KMP与Trie 点击查看目录 目录 「学习笔记」字符串基础:Hash,KMP与Trie Hash 算法 代码 KMP 算法 前置知识:\(\text{Border} ...

  8. 「学习笔记」wqs二分/dp凸优化

    [学习笔记]wqs二分/DP凸优化 从一个经典问题谈起: 有一个长度为 \(n\) 的序列 \(a\),要求找出恰好 \(k\) 个不相交的连续子序列,使得这 \(k\) 个序列的和最大 \(1 \l ...

  9. 「学习笔记」珂朵莉树 ODT

    珂朵莉树,也叫ODT(Old Driver Tree 老司机树) 从前有一天,珂朵莉出现了... 然后有一天,珂朵莉树出现了... 看看图片的地址 Codeforces可还行) 没错,珂朵莉树来自Co ...

  10. 「学习笔记」ST表

    问题引入 先让我们看一个简单的问题,有N个元素,Q次操作,每次操作需要求出一段区间内的最大/小值. 这就是著名的RMQ问题. RMQ问题的解法有很多,如线段树.单调队列(某些情况下).ST表等.这里主 ...

随机推荐

  1. Kubernetes集群调度增强之超容量扩容

    作者:京东科技 徐宪章 1 什么是超容量扩容 超容量扩容功能,是指预先调度一定数量的工作节点,当业务高峰期或者集群整体负载较高时,可以使应用不必等待集群工作节点扩容,从而迅速完成应用横向扩容.通常情况 ...

  2. API Gateway vs Load Balancer：选择适合你的网络流量管理组件

    本文从对比了 API Gateway 和 Load Balancer 的功能区别,帮助读者更好地了解他们在系统架构中扮演的角色. 作者陈泵,API7.ai 技术工程师. 原文链接 由于互联网技术的发展 ...

  3. LLM（大语言模型）解码时是怎么生成文本的？

    Part1配置及参数 transformers==4.28.1 源码地址:transformers/configuration_utils.py at v4.28.1 · huggingface/tr ...

  4. [Pytorch框架] 2.4 卷积神经网络简介

    文章目录 2.4 卷积神经网络简介 2.4.1 为什么要用卷积神经网络 2.4.2结构组成 卷积层 卷积计算 卷积核大小 f 边界填充 (p)adding 步长 (s)tride 计算公式 卷积层 激 ...

  5. 继承 extends

    首先是基础的继承关系,用extend就可以继承. 再者是继承的东西,包括:变量(也包括类变量).全部非私有的属性和方法(除了父类的构造方法) 注:构造方法 class C{ public C() { ...

  6. 2022-06-26：以下golang代码输出什么？A：true；B：false；C：编译错误。 package main import “fmt“ func main() { type

    2022-06-26:以下golang代码输出什么?A:true:B:false:C:编译错误. package main import "fmt" func main() { t ...

  7. 2021-09-25：给定一个字符串数组，将字母异位词组合在一起。可以按任意顺序返回结果列表。字母异位词指字母相同，但排列不同的字符串。示例 1:输入: strs = [“eat“, “tea“, “

    2021-09-25:给定一个字符串数组,将字母异位词组合在一起.可以按任意顺序返回结果列表.字母异位词指字母相同,但排列不同的字符串.示例 1:输入: strs = ["eat" ...

  8. vue全家桶进阶之路28：项目仓库Gitee

    Gitee(之前称为GitCafe)是一种基于web的Git仓库托管服务,在中国很受欢迎.它为开发人员提供了一个平台,可以托管他们的Git仓库,与其他开发人员协作,并管理他们的代码. https:// ...

  9. 洛谷P3374 【模板】树状数组 1-(单点修改,区间查询)

    题目描述 如题,已知一个数列,你需要进行下面两种操作: 将某一个数加上 x 求出某区间每一个数的和 输入格式 第一行包含两个正整数 n,m,分别表示该数列数字的个数和操作的总个数. 第二行包含 n 个 ...

  10. windows下搭建docker容器环境

    下载Docker Desktop https://www.docker.com/ 安装Docker Desktop(软件默认安装c盘,若要安装到其他盘,在安装之前创建软连接再进行安装) 在自定义磁盘中 ...