[数据结构]伸展树(Splay)
![[数据结构]伸展树(Splay)](https://img2020.cnblogs.com/blog/1855237/202108/1855237-20210831212056667-947277167.png)
伸展树（splay）的简单实现及应用
#0.0 写在前面
Splay（伸展树）是较为重要的一种平衡树，理解起来也依旧很容易，但是细节是真的多QnQ，学一次忘一次，还是得用博客加深一下理解（
#1.0 Splay!
#1.1 基本构架
Splay 是如何维护树的平衡的呢？近乎不维护...但其实能使 Splay 的形态接近平衡的原因是每一次操作后都将操作的点拉到根部（splay() 操作），这似乎是基于统计学的某个结论：这次操作过的数据很有可能还是下一次的操作目标(?)不懂欸QuQ
总之，在实践中我们可以得到这样一点：Splay 能用，并且好用！这就足够了。
对于 Splay 上的每个节点，我们维护如下几个信息：
struct Tree {int son[2], f, cnt, size, val;} t[N];
此外还有一些较为常用的基本操作如下：
inline void clear(int k) { //清空 k 号节点
t[k].cnt = t[k].f = t[k].size = t[k].son[1] = t[k].son[0] = t[k].val = 0;
}
inline void pushup(int k) { //更新 k 号点的大小
t[k].size = t[t[k].son[0]].size + t[t[k].son[1]].size + t[k].cnt;
}
/*获取当前节点的儿子种类，0 为左儿子，1 为右儿子*/
inline int get(int k) {return k == t[t[k].f].son[1];}
/*将 x 作为 y 的 op 儿子（0 左 1 右）连边*/
inline void connect(int x, int y, int op) {
if (x) {t[x].f = y;} if (y) {t[y].son[op] = x;}
}
#1.2 核心操作
核心操作当然就是 splay() 操作了，它可以将一个点拉到根部。splay() 操作中将一个点上旋的操作是一次旋两个点：
- 父亲与儿子的儿子类型相同，先旋父亲再旋儿子；
- 父亲与儿子的儿子类型不同，先旋儿子再旋父亲；
- 如果父亲是根，那么只旋儿子。
这里的旋转依旧是传统的左旋和右旋，但是我们不再分开讨论，将他们的共同点抽象出来，我们不难得到以下结论：
设当前要旋转的点是 \(k\)，\(f\) 是 \(k\) 的父亲，\(ff\) 是 \(f\) 的父亲，\(r\) 是 \(k\) 的儿子类型， \(rf\) 是 \(f\) 的儿子类型，那么我们应当将 \(k\) 的 \(r\ \hat{}\ 1\) 类型的儿子作为 \(f\) 新的 \(r\) 类型的孩子，\(f\) 变为 \(k\) 的 \(r\ \hat{}\ 1\) 类型的儿子，\(k\) 作为 \(ff\) 的新的 \(rf\) 类型的孩子。
经过以上的抽象，旋转操作就变得简洁很多了。
inline void rotate(int k) {
int f = t[k].f, ff = t[f].f, r = get(k), rf = get(f);
connect(t[k].son[r ^ 1], f, r); connect(f, k, r ^ 1);
connect(k, ff, rf); pushup(f); pushup(k);
}
inline void splay(int k) {
for (int f = t[k].f; f = t[k].f, f; rotate(k))
if (t[f].f) rotate(get(k) == get(f) ? f : k);
rt = k;
}
#1.3 基本操作
记住一点，不论什么操作后都需要将对应的节点通过 splay() 拉至根部。
#1.3.1 插入
插入的本质就是 BST 的插入，从根节点向下，不断根据权值大小判断进入哪个子树，插入后需要将操作的节点 splay() 至根部。
inline void insert(int k) {
if (!rt){
rt = ++ tot, t[rt].val = k;
t[rt].cnt ++; pushup(rt); return;
}
int now = rt, f = 0;
while (true) {
if (t[now].val == k) {
t[now].cnt ++; pushup(now);
pushup(f); splay(now); break;
}
f = now; now = t[now].son[t[now].val < k];
if (! now) {
t[++ tot].val = k, t[tot].f = f;
t[tot].cnt ++; t[f].son[t[f].val < k] = tot;
pushup(tot); pushup(f); splay(tot); break;
}
}
}
#1.3.2 查询排名
根据权值大小判断进入左子树还是右子树，进入右子树时需要加上当前节点的大小和左子树的大小。查询结束后进行 splay() 操作。
inline int rk(int k) {
int res = 0, now = rt;
while (true) {
if (k < t[now].val) now = t[now].son[0];
else {
res += t[t[now].son[0]].size;
if (k == t[now].val) splay(now), return res + 1;
res += t[now].cnt; now = t[now].son[1];
}
}
}
#1.3.3 查询第 k 大
依旧是传统的通过左子树大小进行查找。
inline int kth(int k) {
int now = rt;
while (true) {
if (k <= t[t[now].son[0]].size) now = t[now].son[0];
else {
k -= t[t[now].son[0]].size + t[now].cnt;
if (k <= 0) splay(now), return t[now].val;
now = t[now].son[1];
}
}
}
#1.3.4 前驱 & 后继
我们直接将要查前驱/后继的数插入 Splay，此时所在节点就被拉到了根部，直接找根的左/右子树的最右/左点即可，最后再删掉该点。
inline int pre() {
int cur = t[rt].son[0];
while (t[cur].son[1]) cur = t[cur].son[1];
splay(cur); return cur;
}
inline int nxt() {
int cur = t[rt].son[1];
while (t[cur].son[0]) cur = t[cur].son[0];
splay(cur); return cur;
}
#1.3.5 删除
主要是进行分类讨论，这一部分不多解释，详见下方代码
inline void del(int k) {
rk(k); //调用 rk() 的主要目的是将该点拉到根部
if (t[rt].cnt > 1) {
t[rt].cnt --; pushup(rt); return;
} else if (!t[rt].son[0] && !t[rt].son[1]) {
clear(rt); rt = 0; return;
} else if (!t[rt].son[0]) {
int tmp = rt; rt = t[tmp].son[1];
t[rt].f = 0; clear(tmp); return;
} else if (!t[rt].son[1]) {
int tmp = rt; rt = t[tmp].son[0];
t[rt].f = 0; clear(tmp); return;
}
int tmp = rt, l = pre(); splay(l);
/*分析旋转过程不难发现，前驱的右子树一定为空*/
/*同样在最终将前驱旋转至根部时，右子树一定也为空*/
/*所以最后要删掉点的左子树一定为空*/
/*也可以考虑 BST 的性质，前驱和当前点之间不会再有其他点*/
connect(t[tmp].son[1], rt, 1);
clear(tmp); pushup(rt);
}
#2.0 经典例题
#2.1 P3369 【模板】普通平衡树
就是上面操作的结合。
const int N = 100010;
const int INF = 0x3fffffff;
struct Tree {int son[2], f, cnt, size, val;} t[N];
int rt, tot, n;
inline void clear(int k) {
t[k].cnt = t[k].f = t[k].size = t[k].son[1] = t[k].son[0] = t[k].val = 0;
}
inline void pushup(int k) {
t[k].size = t[t[k].son[0]].size + t[t[k].son[1]].size + t[k].cnt;
}
inline int get(int k) {return k == t[t[k].f].son[1];}
inline void connect(int x, int y, int op) {
if (x) {t[x].f = y;} if (y) {t[y].son[op] = x;}
}
inline void rotate(int k) {
int f = t[k].f, ff = t[f].f, r = get(k), rf = get(f);
connect(t[k].son[r ^ 1], f, r); connect(f, k, r ^ 1);
connect(k, ff, rf); pushup(f); pushup(k);
}
inline void splay(int k) {
for (int f = t[k].f; f = t[k].f, f; rotate(k))
if (t[f].f) rotate(get(k) == get(f) ? f : k);
rt = k;
}
inline void insert(int k) {
if (!rt){
rt = ++ tot, t[rt].val = k;
t[rt].cnt ++; pushup(rt); return;
}
int now = rt, f = 0;
while (true) {
if (t[now].val == k) {
t[now].cnt ++; pushup(now);
pushup(f); splay(now); break;
}
f = now; now = t[now].son[t[now].val < k];
if (! now) {
t[++ tot].val = k, t[tot].f = f;
t[tot].cnt ++; t[f].son[t[f].val < k] = tot;
pushup(tot); pushup(f); splay(tot); break;
}
}
}
inline int rk(int k) {
int res = 0,now = rt;
while (true) {
if (k < t[now].val) now = t[now].son[0];
else {
res += t[t[now].son[0]].size;
if (k == t[now].val) splay(now), return res + 1;
res += t[now].cnt; now = t[now].son[1];
}
}
}
inline int kth(int k) {
int now = rt;
while (true) {
if (k <= t[t[now].son[0]].size) now = t[now].son[0];
else {
k -= t[t[now].son[0]].size + t[now].cnt;
if (k <= 0) splay(now), return t[now].val;
now = t[now].son[1];
}
}
}
inline int pre() {
int cur = t[rt].son[0];
while (t[cur].son[1]) cur = t[cur].son[1];
splay(cur); return cur;
}
inline int nxt() {
int cur = t[rt].son[1];
while (t[cur].son[0]) cur = t[cur].son[0];
splay(cur); return cur;
}
inline void del(int k) {
rk(k);
if (t[rt].cnt > 1) {
t[rt].cnt --; pushup(rt); return;
} else if (!t[rt].son[0] && !t[rt].son[1]) {
clear(rt); rt = 0; return;
} else if (!t[rt].son[0]) {
int tmp = rt; rt = t[tmp].son[1];
t[rt].f = 0; clear(tmp); return;
} else if (!t[rt].son[1]) {
int tmp = rt; rt = t[tmp].son[0];
t[rt].f = 0; clear(tmp); return;
}
int tmp = rt, l = pre(); splay(l);
connect(t[tmp].son[1], rt, 1);
clear(tmp); pushup(rt);
}
int main() {
scanf("%d", &n); int opt,x;
while (n --){
scanf("%d%d", &opt, &x);
if (opt == 1) insert(x);
else if (opt == 2) del(x);
else if (opt == 3) printf("%d\n", rk(x));
else if (opt == 4) printf("%d\n", kth(x));
else if (opt == 5)
insert(x), printf("%d\n", t[pre()].val), del(x);
else insert(x), printf("%d\n", t[nxt()].val), del(x);
}
return 0;
}
#2.2 P3391 【模板】文艺平衡树
这题用到了 Splay 的另一个应用：处理序列。
对于每个节点，我们再多维护一个 tag，表示当前节点的子树的所有节点的左右儿子是否交换，通过两次 splay() 操作可以将操作区间提取出来。注意在旋转之前需要将当前节点和父亲节点的标记下传。
const int N = 400010;
const int INF = 0x3fffffff;
struct Tree {int son[2], f, cnt, size, val, tg;} t[N];
int rt,tot, n,m;
inline void clear(int k) {
t[k].cnt = t[k].f = t[k].size = t[k].son[1] = t[k].son[0] = t[k].val = 0;
}
inline void pushup(int k) {
t[k].size = t[t[k].son[0]].size + t[t[k].son[1]].size + t[k].cnt;
}
inline void pushdown(int k) {
if (t[k].tg){
t[t[k].son[0]].tg ^= 1; t[t[k].son[1]].tg ^= 1;
swap(t[k].son[0],t[k].son[1]); t[k].tg = 0;
}
}
inline int get(int k) {return k == t[t[k].f].son[1];}
inline void connect (int x, int y, int op){
if (x) {t[x].f = y;} if (y) {t[y].son[op] = x;}
}
inline void rotate(int k) {
pushdown(t[k].f), pushdown(k),;
int f = t[k].f, ff = t[f].f, r = get(k), rf = get(f);
connect(t[k].son[r ^ 1], f, r); connect(f, k, r ^ 1);
connect(k, ff, rf); pushup(f); pushup(k);
}
inline void splay(int k, int g) {
for (int f = t[k].f; f = t[k].f, f != g; rotate(k))
if (t[f].f != g) rotate(get(k) == get(f) ? f : k);
if (!g) rt = k;
}
inline int kth(int k) {
int now = rt;
while (true){
pushdown(now);
if (t[t[now].son[0]].size >= k)
now = t[now].son[0];
else{
k -= t[t[now].son[0]].size + t[now].cnt;
if (k <= 0) return now;
now = t[now].son[1];
}
}
}
inline void reverse(int x, int y) {
int l = x - 1, r = y + 1;
l = kth(l + 1); r = kth(r + 1);
splay(l, 0); splay(r, l);
int cur = t[rt].son[1];
cur = t[cur].son[0];
t[cur].tg ^= 1;
}
inline void print(int k) {
pushdown(k);
if (t[k].son[0]) print(t[k].son[0]);
if (t[k].val != 0 && t[k].val != n + 1)
printf("%d ",t[k].val);
if (t[k].son[1]) print(t[k].son[1]);
}
inline void build(int l, int r, int k, int f) {
if (l > r) return;
if (l == r){
t[k].f = f; t[k].val = l;
t[k].cnt = t[k].size = 1;
return;
}
int mid = (l + r) >> 1;
t[k].f = f; t[k].val = mid; t[k].cnt = 1;
t[k].son[0] = ++ tot; build(l, mid - 1, tot, k);
t[k].son[1] = ++ tot; build(mid + 1, r, tot, k);
pushup(k);
}
int main(){
scanf("%d%d", &n, &m);
build(0, n + 1, ++ tot, 0);
rt = 1;
while (m --){
int x, y; scanf("%d%d", &x, &y); reverse(x, y);
}
print(rt);
return 0;
}
``
