算法学习笔记（15）： Splay树

合集 - 算法(31)

1.算法学习笔记（1）：CDQ分治2023-11-172.算法学习笔记（2）：分块2023-11-303.算法学习笔记（3）：莫队算法2024-01-014.算法学习笔记（4）：FHQ平衡树（无旋平衡树）2024-01-015.算法学习笔记（5）：AC自动机2024-01-016.算法学习笔记（6）：优秀trick和性质合集2024-03-097.算法学习笔记（7）：数论2024-03-098.算法学习笔记（9）：第k大问题合集2024-03-169.算法学习笔记（10）：各种序的美好性质2024-03-1610.算法学习笔记（11）：历史版本和线段树2024-03-3111.算法学习笔记（12）：左偏树2024-04-0812.算法学习笔记（13）：同余最短路2024-04-1213.算法学习笔记（14）：区间最值操作和历史最值问题2024-04-28

14.算法学习笔记（15）： Splay树2024-05-06

15.算法学习笔记（16）：Link Cut Tree2024-05-0716.算法学习笔记（17）：Slope trick2024-05-1017.算法学习笔记（18）：珂朵莉树2024-05-1318.算法学习笔记（20）：网络流2024-05-1719.算法学习笔记（21）：数论分块2024-06-0620.算法学习笔记（22）：莫比乌斯反演2024-06-0621.算法学习笔记（23）：杜教筛2024-06-0722.算法学习笔记（24）：筛法2024-06-0823.暑假集训学习笔记（1）：lxl DS Day 12024-07-0224.暑假集训学习笔记（2）：lxl DS Day 22024-07-0225.暑假集训学习笔记（3）：lxl DS Day 32024-07-0426.多项式笔记2024-07-0827.生成函数笔记2024-07-0828.插头DP2024-07-2529.DP选讲做题记录 by 付乙淼2024-07-2630.拓展摩尔投票2024-09-1831.图论知识总结2024-09-25

收起

Splay树

Splay树又名伸展树， 是tarjan为LCT而发明的平衡树， 通过旋转操作维护二叉搜索树的高度平衡, 其实不管时间复杂度的证明， Splay树挺简单的。 均摊复杂度 $O(logn)$（需要用到势能分析）， 可以区间操作， 不能可持久化， 常数较大（大于FHQtreap）， 但是可以 $O(nlogn)$ 实现 LCT。（这是唯一比FHQtreap优秀的店...）

算法

splay树通常是把需要操作的点旋转到根， 这样就可以进行 $O(1)$ 的操作， 同时旋转时要注意不能无脑转， 要兼顾高度平衡。

rotate操作

分为左旋和右旋， 目的是将节点 $x$ 旋转到父亲 $f$ 的位置。 （图例搬的OI-wiki）

splay操作

这是将某个节点旋转到根节点处的一系列操作， 我们将其统称为splay操作。 也就是说会经历若干个左旋和右旋操作， 从而将 $x$ 旋转到根。
splay操作需要分类讨论：
此处请见OI-wiki splay分类讨论 (太懒了)
之所以我们要这样分类讨论， 是因为遵循这些规则转的话可以使高度较为平衡， 接近于 $O(logn)$， 从而达到均摊复杂度 $O(logn)$。

模板代码

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct Splay{
	int rt, tot, fa[N], ch[N][2], val[N], cnt[N], siz[N];
	void maintain(int u) { siz[u] = siz[ch[u][0]] + siz[ch[u][1]] + cnt[u]; }
	bool get(int u) { return u == ch[fa[u]][1]; }
	void clear(int u) { ch[u][0] = ch[u][1] = fa[u] = val[u] = cnt[u] = siz[u] = 0; }
	void rotate(int u) {
		int f = fa[u], gf = fa[f], chk = get(u);
		ch[f][chk] = ch[u][chk ^ 1];
		if (ch[u][chk ^ 1]) fa[ch[u][chk ^ 1]] = f;
		ch[u][chk ^ 1] = f;
		fa[f] = u;
		fa[u] = gf;
		if (gf) ch[gf][f == ch[gf][1]] = u;
		maintain(u);
		maintain(f);
	} 
	void splay(int u) {
		for (int f = fa[u]; f = fa[u], f; rotate(u)) 
			if (fa[f]) rotate(get(u) == get(f) ? f : u);
		rt = u;
	}
	void ins(int k) {
		if (!rt) {
			val[++tot] = k, cnt[tot]++;
			rt = tot;
			maintain(rt);
			return;
		}
		int cur = rt, f = 0;
		while (1) {
			if (val[cur] == k) {
				cnt[cur]++;
				maintain(cur);
				maintain(f);
				splay(cur);
				break;
			}
			f = cur;
			cur = ch[cur][val[cur] < k];
			if (!cur) {
				val[++tot] = k;
				cnt[tot]++;
				fa[tot] = f;
				ch[f][val[f] < k] = tot;
				maintain(tot);
				maintain(f);
				splay(tot);
				break;
			}
		}
	}
	int rk(int k) {
		int res = 0, cur = rt;
		while (1) {
			if (k < val[cur]) cur = ch[cur][0];
			else {
				res += siz[ch[cur][0]];
				if (!cur) return res + 1;
				if (k == val[cur]) {
					splay(cur);
					return res + 1;
				}
				res += cnt[cur];
				cur = ch[cur][1];
			}
		}
	}
	int kth(int k) {
		int cur = rt;
		while (1) {
			if (ch[cur][0] && k <= siz[ch[cur][0]]) cur = ch[cur][0];
			else {
				k -= cnt[cur] + siz[ch[cur][0]];
				if (k <= 0) {
					splay(cur);
					return val[cur];	
				}
				cur = ch[cur][1];
			}
		}
	} 
	int pre() {
		int cur = ch[rt][0];
		if (!cur) return cur;
		while (ch[cur][1]) cur = ch[cur][1];
		splay(cur);
		return cur;
	}
	int suf() {
		int cur = ch[rt][1];
		if (!cur) return cur;
		while (ch[cur][0]) cur = ch[cur][0];
		splay(cur);
		return cur;
	}
	void del(int k) {
		rk(k);
		if (cnt[rt] > 1) {
			cnt[rt]--;
			maintain(rt);
			return;
		}
		if (!ch[rt][0] && !ch[rt][1]) {
			clear(rt);
			rt = 0;
			return;
		}
		if (!ch[rt][0]) {
			int cur = rt;
			rt = ch[rt][1];
			fa[rt] = 0;
			clear(cur);
			return;
		}
		if (!ch[rt][1]) {
			int cur = rt;
			rt = ch[rt][0];
			fa[rt] = 0;
			clear(cur);
			return;
		}
		int cur = rt;
		int x = pre();
		fa[ch[cur][1]] = x;
		ch[x][1] = ch[cur][1];
		clear(cur);
		maintain(rt);
	}
}T;
int n;
int main() {
	scanf("%d", &n);
	for (int i = 1, op, x; i <= n; i++) {
		scanf("%d%d", &op, &x);
		switch(op) {
			case 1: T.ins(x); break;
			case 2: T.del(x); break;
			case 3: printf("%d\n", T.rk(x)); break;
			case 4: printf("%d\n", T.kth(x)); break;
			case 5: T.ins(x); printf("%d\n", T.val[T.pre()]); T.del(x); break;
			case 6: T.ins(x); printf("%d\n", T.val[T.suf()]); T.del(x); break;
		} 
	}
	return 0;
}

区间操作

区间翻转

可以打一个懒标记， 至于怎么打， 就是把代表区间 $(l,r)$ 的子树提出来， 然后打标记。 类似FHQ的， 我们需要按照数组下标为BST的键值建树。
方法： 将 $l-1$ 旋转到根， 将 $r+1$ 旋转到 $l-1$ 的右儿子， 这样区间 $(l,r)$ 就都在 $r+1$ 的左子树里， 直接打标记就可以了。

模板代码

点击查看代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int INF = 1e9;
int a[N];
struct Splay{
	int tot, rt, cnt[N], siz[N], val[N], ch[N][2], fa[N], tag[N];
	void maintain(int u) { siz[u] = siz[ch[u][0]] + siz[ch[u][1]] + cnt[u]; }
	void clear(int u) { cnt[u] = siz[u] = val[u] = ch[u][0] = ch[u][1] = fa[u] = tag[u] = 0; }
	bool get(int u) { return u == ch[fa[u]][1]; }
	void pushdown(int u) {
		if (u && tag[u]) {
			tag[ch[u][0]] ^= 1;
			tag[ch[u][1]] ^= 1;
			swap(ch[u][0], ch[u][1]);
			tag[u] = 0; 
		}
	}  
	void build(int &p, int l, int r, int pre) {
		if (l > r) return;
		p = ++tot; int mid = l + r >> 1;
		cnt[tot]++, val[tot] = a[mid], fa[tot] = pre;
		build(ch[p][0], l, mid - 1, p);
		build(ch[p][1], mid + 1, r, p);
		maintain(p);
	}
	void rotate(int u) {
		int f = fa[u], gf = fa[f], chk = get(u);
		pushdown(f); pushdown(u);
		ch[f][chk] = ch[u][chk ^ 1];
		if (ch[u][chk ^ 1]) fa[ch[u][chk ^ 1]] = f;
		ch[u][chk ^ 1] = f;
		fa[f] = u;
		fa[u] = gf;
		if (gf) ch[gf][f == ch[gf][1]] = u;
		maintain(u);
		maintain(f);
	}
	void splay(int u, int goal) {
		for (int f = fa[u]; (f = fa[u]) != goal; rotate(u)) 
			if (fa[f] != goal) rotate(get(f) == get(u) ? f : u);
		if (!goal) rt = u;
	}
	int kth(int k) {
		int cur = rt;
		while(1) {
			pushdown(cur);
			if (ch[cur][0] && k <= siz[ch[cur][0]]) cur = ch[cur][0];
			else  {
				k -= siz[ch[cur][0]] + cnt[cur];
				if (k <= 0) return cur;
				cur = ch[cur][1];
			}
		}
	}
	void reverse(int l, int r) {
		l = l - 1, r = r + 1;
		l = kth(l), r = kth(r);
		splay(l, 0); splay(r, l);
		tag[ch[r][0]] ^= 1;
	}
	void print(int u) {
		pushdown(u);
		if (ch[u][0]) print(ch[u][0]);
		if (val[u] != -INF && val[u] != INF) printf("%d ", val[u]);
		if (ch[u][1]) print(ch[u][1]);
	}
}T;
int n, m;
int main() {
	scanf("%d%d", &n, &m);
	a[1] = -INF, a[n + 2] = INF;
	for (int i = 2; i <= n + 1; i++) a[i] = i - 1;
	T.build(T.rt, 1, n + 2, 0); 
	for (int i = 1, l, r; i <= m; i++) {
		scanf("%d%d", &l, &r);
		l++, r++;
		T.reverse(l, r);
	}
	T.print(T.rt);
	return 0;
}