平衡树 -- Splay & Treap
Treap & Splay学习笔记
前置知识 -- BST
二叉搜索树，一种比较好玩的数据结构，其实现原理是运用每个点的权值构建，其中满足这样的构造方式：
若 \(value > t[x].value\) , 则权值为 \(value\) 的点在 \(x\) 的左子树
反之( \(value < t[x].value\) ) , 则权值为 \(value\) 的点在 \(x\) 右子树
比如我们可以构建这样的 \(BST\) :
4
/ \
3 5
/ \
2 10
/ \
9 12
... 看起来如果这个数据给的比较正的话，就会使查点的时间复杂度为 \(\log{n}\) 的。
但如果这个数据这么给你： 1 2 3 4 5 6 7 8 9 10
那么你的树就变成链了，查的复杂度为 \(n\) 的。
我们发现，在随机数据下，树是趋于平衡的，这样就形成了以随机化为主要思想的平衡树—— Treap
它使用小根堆性质维护树，改变树的形态，却不改变中序遍历。
Treap (rotate)
这是第一种 \(Treap\) ，带旋转的，即用旋转来维护小根堆性质。
具体代码：
void rotate(int &x , int d) { // d 代表左旋还是右旋
int child = t[x].son[d] ;
t[x].son[d] = t[child].son[d ^ 1] , t[child].son[d ^ 1] = x ;
push_up(x) , push_up(x = son) ;
}
普通平衡树的代码：
CODE
#include <bits/stdc++.h>
#define int long long
using namespace std ;
const int N = 1e5 + 10 ;
inline int read() {
int x = 0 , f = 1 ;
char c = getchar() ;
while (c < '0' || c > '9') {
if (c == '-') f = -f ;
c = getchar() ;
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0' ;
c = getchar() ;
}
return x * f ;
}
namespace Treap {
#define lson t[x].son[0]
#define rson t[x].son[1]
class Treap_Point_ {
public :
int Rand , value , son[2] , Size , cnt ;
} t[N] ; int numbol = 0 ;
inline void push_up(int x) {
t[x].Size = t[lson].Size + t[rson].Size + t[x].cnt ;
}
inline void rotate(int &x , int d) {
int child = t[x].son[d] ;
t[x].son[d] = t[child].son[d ^ 1] ; t[child].son[d ^ 1] = x ;
push_up(x) ; push_up(x = child) ;
}
inline void New_Value_Create(int value) {
numbol ++ ; t[numbol].Rand = rand() ;
t[numbol].value = value , t[numbol].Size = t[numbol].cnt = 1 ;
}
void Insert(int &x , int value) {
if (!x) {
New_Value_Create(value) ;
x = numbol ;
return ;
}
if (value == t[x].value) {
t[x].cnt ++ ; t[x].Size ++ ;
return ;
}
t[x].Size ++ ;
int d = value > t[x].value ; Insert(t[x].son[d] , value) ;
if (t[x].Rand > t[t[x].son[d]].Rand) rotate(x , d) ;
}
void deleted(int &x , int value) {
if (!x) return ;
if (t[x].value == value) {
if (t[x].cnt > 1) {
t[x].cnt -- , t[x].Size -- ;
return ;
}
if (lson == 0 || rson == 0) {
x = lson + rson ; return ;
}
bool d = t[lson].Rand > t[rson].Rand ;
rotate(x , d) ; deleted(t[x].son[d ^ 1] , value) ;
push_up(x) ;
} else {
t[x].Size -- ;
int d = value > t[x].value ; deleted(t[x].son[d] , value) ;
push_up(x) ;
}
}
int Rank(int x , int value) {
if (!x) return 114514 - 114514 ;
if (t[x].value == value) return t[lson].Size + 1 ;
if (value < t[x].value) return Rank(lson , value) ;
else return Rank(rson , value) + t[x].cnt + t[lson].Size ;
}
int The_K_th(int root , int k) {
int x = root ;
while (114514) {
if (k <= t[lson].Size) x = lson ;
else if (k > t[x].cnt + t[lson].Size) k -= t[x].cnt + t[lson].Size , x = rson ;
else return t[x].value ;
}
return 1145141919810ll ;
}
int Precursor(int x , int value) {
if (!x) return -1145141919810ll ;
if (t[x].value >= value) return Precursor(lson , value) ;
else return max(t[x].value , Precursor(rson , value)) ;
}
int Subsequent(int x , int value) {
if (!x) return 1145141919810ll ;
if (t[x].value <= value) return Subsequent(rson , value) ;
else return min(t[x].value , Subsequent(lson , value)) ;
}
void Print_Tree(int x) {
cerr << x << ' ' << t[x].value << ":\n" ;
cerr << lson << ' ' << rson << '\n' ;
if (lson) Print_Tree(lson) ;
if (rson) Print_Tree(rson) ;
}
#undef lson
#undef rson
} using namespace Treap ;
int n , opt , root ;
signed main() {
#ifndef ONLINE_JUDGE
freopen("1.in" , "r" , stdin) ;
freopen("1.out" , "w" , stdout) ;
#endif
n = read() ;
int x , y , z ;
for (int i = 1 ; i <= n ; ++ i) {
opt = read() ;
// cerr << opt << '\n' ;
switch (opt) {
case 1 :
x = read() ;
Insert(root , x) ;
break ;
case 2 :
x = read() ;
deleted(root , x) ;
break ;
case 3 :
x = read() ;
cout << Rank(root , x) << '\n' ;
break ;
case 4 :
x = read() ;
cout << The_K_th(root , x) << '\n' ;
break ;
case 5 :
x = read() ;
cout << Precursor(root , x) << '\n' ;
break ;
case 6 :
x = read() ;
cout << Subsequent(root , x) << '\n' ;
break ;
}
}
}
Treap -- without rotating (FHQ Treap)
使用分割和合成来维护堆性质。
其中分割可以用值分，也可以按大小分，后者常用来维护序列。
合并时你要保证 \(x\) 在中序遍历时全部位于 \(y\) 前，即 xy
普通平衡树代码：
CODE
#include <bits/stdc++.h>
#define int long long
using namespace std ;
const int N = 3e5 + 10 ;
const int INF = 1145141919810 ;
inline int read() {
int x = 0 , f = 1 ;
char c = getchar() ;
while (c < '0' || c > '9') {
if (c == '-') f = -f ;
c = getchar() ;
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0' ;
c = getchar() ;
}
return x * f ;
}
namespace Data_Structure {
namespace FHQ_Treap { // As Well as Treap With No Rotate .
#define lson t[x].son[0]
#define rson t[x].son[1]
class Treap_Point_ {
public:
int Rand , cnt , Size , value , son[2] ;
} t[N] ; int numbol = 0 , root = 0 ;
inline void push_up(int x) {
t[x].Size = t[lson].Size + t[rson].Size + t[x].cnt ;
}
int Merge(int x , int y) {
if (!x || !y) return x | y ;
if (t[x].Rand < t[y].Rand) {
rson = Merge(rson , y) ; push_up(x) ;
return x ;
} else {
t[y].son[0] = Merge(x , t[y].son[0]) ; push_up(y) ;
return y ;
}
}
void Split(int id , int value , int &x , int &y) {
if (!id) {
x = y = 0 ; return ;
}
if (t[id].value <= value) {
x = id ; Split(t[id].son[1] , value , t[x].son[1] , y) ;
push_up(x) ;
} else {
y = id ; Split(t[id].son[0] , value , x , t[y].son[0]) ;
push_up(y) ;
}
}
inline int New_Value_Create(int value) {
++ numbol ;
t[numbol].value = value , t[numbol].Size = t[numbol].cnt = 1 ; t[numbol].Rand = rand() ;
return numbol ;
}
int The_K_th(int root , int k) {
int x = root ;
while (114514) {
if (k <= t[lson].Size) x = lson ;
else if (k > t[lson].Size + t[x].cnt) k -= t[lson].Size + t[x].cnt , x = rson ;
else return t[x].value ;
}
}
void Insert(int value) {
int x , y ;
Split(root , value , x , y) ;
root = Merge(Merge(x , New_Value_Create(value)) , y) ;
}
void Delete(int value) {
int x , y , z ;
Split(root , value , x , z) ;
Split(x , value - 1 , x , y) ;
y = Merge(t[y].son[0] , t[y].son[1]) ;
root = Merge(Merge(x , y) , z) ;
}
int Rank(int value) {
int x , y , ans ;
Split(root , value - 1 , x , y) ;
ans = t[x].Size + 1 ;
root = Merge(x , y) ;
return ans ;
}
int Precursor(int value) {
int x , y , ans ;
Split(root , value - 1 , x , y) ;
ans = The_K_th(x , t[x].Size) ;
root = Merge(x , y) ;
return ans ;
}
int Subsequent(int value) {
int x , y , ans ;
Split(root , value , x , y) ;
ans = The_K_th(y , 1) ;
root = Merge(x , y) ;
return ans ;
}
#undef lson
#undef rson
}
} using namespace Data_Structure ;
using namespace FHQ_Treap ;
int n , opt ;
signed main() {
#ifndef ONLINE_JUDGE
freopen("1.in" , "r" , stdin) ;
freopen("1.out" , "w" , stdout) ;
#endif
n = read() ; int x , y , z ; int num = 0 ;
while (n --) {
opt = read() ;
switch (opt) {
case 1 :
x = read() ; Insert(x) ;
break ;
case 2 :
x = read() ; Delete(x) ;
break ;
case 3 : ++ num ;
x = read() ; cout << Rank(x) << '\n' ;
break ;
case 4 : ++ num ;
x = read() ; cout << The_K_th(root ,x) << '\n' ;
break ;
case 5 : ++ num ;
x = read() ; cout << Precursor(x) << '\n' ;
break ;
case 6 : ++ num ;
x = read() ; cout << Subsequent(x) << '\n' ;
break ;
}
}
}
Splay (伸展树)
一种神奇数据结构。
其实现是基于 局部性原理
局部性原理
局部性(locality) 可以分为时间局部性(temporal locality) 和空间局部性(spatial locality)
假如你在书桌旁工作，需要查阅某本书籍，你又发现这本书用的非常之经常，于是你就把书放在手边，不再放回去。这就是 时间局部性
如果你在图书馆里找到了蓝书，但发现蓝书上并没有讲 \(Splay\) ，但是其隔壁的书上可能有 \(Splay\) . 这就是 空间局部性
于是我们整体归纳一下：
1> 刚刚被访问的元素极有可能再次被访问
2> 刚刚被访问的元素旁极有可能放着下一个被访问的元素
而我们的 \(Splay\) , 使用了这一原理，虽然可能单独的复杂度是 \(O(n)\) , 但均摊为 \(O(\log n)\)
Splay 用法
我们使用 \(E\) , 则节点 \(E\) 就会被上升到根：
因为两侧子树的结构在不断地调整，所以形象称之为伸展。但是好像进行单次的旋转，某些情况下复杂度依然高达 \(O(n)\)
我们来看最坏情况下的旋转5：
还是一条链！
这种情况如何伸展？
双层伸展
如果 \(x\) 和 \(fa_x\) 和 \(fa_{fa_x}\) 在同一条链上时，我们采用双层伸展，使其高度迅速减小
下面展示了一种因为节点更多，更加效率的树：
尽管 \(Splay\) 不像 \(AVL\) 和 红黑树这么严格，如果存在超深节点，就会因为 \(Splay\) 操作使得高度迅速减半。因此保证了整体的高效率。
具体实现
rotate : 其实很像 \(Treap\) 的，就是需要保存父亲。
template <typename T> void rotate(T x) {
int Grandfather = t[fath].father , Old_fa = fath ; bool d = Get_Direction(x) ;
t[Grandfather].son[Get_Direction(Old_fa)] = x , t[Old_fa].son[d] = t[x].son[d ^ 1] , t[x].son[d ^ 1] = Old_fa ;
Recognize_Father(Grandfather) ; Recognize_Father(Old_fa) ; Recognize_Father(x) ;
push_up(Old_fa) , push_up(x) ;
}
Splay : 注意一点细节即可。
void Splay(int x , int End) {
while (fath != End) {
int Old_fa = fath , Grandfather = t[fath].father ;
if (Grandfather != End) {
if (Get_Direction(x) == Get_Direction(Old_fa)) rotate(Old_fa) ;
else rotate(x) ;
}
rotate(x) ;
}
if (!End) root = x ;
}
一个很重要的事情：
你是否觉得Splay很高级很好用？那么我要告诉你，缺点就是：
常数巨大
Splay 的应用
由于旋旋旋旋，所以可以进行一点区间操作。
例： \([l , r]\) 将 \(l - 1\) 放置于根，然后将 \(r + 1\) 放到根的右儿子，那么根的右儿子的左子树就是这个区间。
呃呃呃，由于 \(Splay\) 常数巨大所以跑的有点小慢(⊙o⊙)…
例题： luoguP3380树套树
CODE
#include <bits/stdc++.h>
#define getchar() getchar_unlocked()
#define int long long
using namespace std ;
const int N = 4e5 + 10 ;
const int INF = 2147483647 ;
const int Size = 1e8 + 1 ;
inline int read() {
int x = 0 , f = 1 ;
char c = getchar() ;
while (c < '0' || c > '9') {
if (c == '-') f = -f ;
c = getchar() ;
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0' ;
c = getchar() ;
}
return x * f ;
}
int root[N * 10] ;
namespace SPLAY {
#define lson t[x].son[0]
#define rson t[x].son[1]
#define fath t[x].father
class Splay_Point_ {
public :
int son[2] , father , value , Size , cnt , pos ;
} t[N * 20] ; int numbol = 0 ;
void Print(int x) {
cerr << t[x].pos << ":\n" ;
cerr << t[lson].pos << ' ' << t[rson].pos << '\n' ;
if (lson) Print(lson) ;
if (rson) Print(rson) ;
}
int Create(int value) {
numbol ++ ;
t[numbol].cnt = t[numbol].Size = 1 ; t[numbol].value = value ;
return numbol ;
}
inline void push_up(int x) {
t[x].Size = t[lson].Size + t[rson].Size + t[x].cnt ;
}
inline bool Get_Direction(int x) {
return t[fath].son[1] == x ;
}
inline void Recognize_Father(int x) {
t[lson].father = t[rson].father = x ;
}
inline void rotate(int x) {
int Grandfather = t[fath].father , Old_fa = fath ; bool d = Get_Direction(x) ;
t[Grandfather].son[Get_Direction(Old_fa)] = x , t[Old_fa].son[d] = t[x].son[d ^ 1] , t[x].son[d ^ 1] = Old_fa ;
Recognize_Father(Grandfather) ; Recognize_Father(Old_fa) ; Recognize_Father(x) ;
push_up(Old_fa) , push_up(x) ;
}
void Splay(int x , int End , int Tree) {
while (fath != End) {
int Old_fa = fath , Grandfather = t[fath].father ;
if (Grandfather != End) {
if (Get_Direction(x) == Get_Direction(Old_fa)) rotate(Old_fa) ;
else rotate(x) ;
}
rotate(x) ;
}
if (!End) root[Tree] = x ;
}
void Insert(int x , int pos , int value , int Tree) {
int needfather = 0 ;
while (x && t[x].pos != pos) {
needfather = x ;
x = t[x].son[pos > t[x].pos] ;
}
if (x) {
t[x].Size ++ ; t[x].cnt ++ ; Splay(x , 0ll , Tree) ;
} else {
x = Create(value) ; fath = needfather ; t[fath].son[pos > t[fath].pos] = x ; t[x].pos = pos ;
Splay(x , 0ll , Tree) ;
}
}
int Rank(int root , int pos , int Tree) {
if (root == 0) return 0 ;
int x = root , ans = 0 , need = 0 ;
while (x) {
need = x ;
if (t[x].pos > pos) x = lson ;
else ans += t[x].cnt + t[lson].Size , x = rson ;
}
Splay(need , 0ll , Tree) ;
return ans ;
}
int Find(int root , int pos , int Tree) {
int x = root ;
while (x && t[x].pos != pos) x = t[x].son[pos > t[x].pos] ;
if (x == 0) return 0 ;
else {
Splay(x , 0ll , Tree) ; return x ;
}
}
int Precursor_Or_Subsquent(int x , bool d , int Tree) {
Splay(x , 0ll , Tree) ;
x = t[x].son[d] ;
while (t[x].son[d ^ 1]) x = t[x].son[d ^ 1] ;
return x ;
}
void Delete(int root , int val , int Tree) {
int x = Find(root , val , Tree) ;
if (!x) return ;
if (t[x].cnt > 1) {
t[x].cnt -- ; t[x].Size -- ;
Splay(x , 0ll , Tree) ;
return ;
}
int Pre = Precursor_Or_Subsquent(x , 0 , Tree) , Sub = Precursor_Or_Subsquent(x , 1 , Tree) ;
Splay(Pre , 0ll , Tree) ; Splay(Sub , Pre , Tree) ; t[Sub].son[0] = 0 ;
}
#undef lson
#undef rson
#undef fath
}
namespace SEGMENT_TREE {
#define lson t[id].son[0]
#define rson t[id].son[1]
#define mid ((l + r) >> 1)
using SPLAY :: Insert ;
using SPLAY :: Rank ;
using SPLAY :: Delete ;
using SPLAY :: Print ;
struct Tree_Point_ {
int son[2] ;
} t[N * 20] ; int numbol = 0 ;
int New_Code() {
++ numbol ;
Insert(root[numbol] , INF , INF , numbol) ; Insert(root[numbol] , -INF , INF , numbol) ;
return numbol ;
}
void updata(int &id , int l , int r , int x , int v) {
if (!id) id = New_Code() ;
Insert(root[id] , v , x , id) ;
if (l == r) return ;
if (x <= mid) updata(lson , l , mid , x , v) ;
else updata(rson , mid + 1 , r , x , v) ;
}
int GetRank(int id , int l , int r , int x , int y , int v) {
if (l == r) return 1 ;
if (v <= mid) return GetRank(lson , l , mid , x , y , v) ;
else {
int ans = Rank(root[lson] , y , lson) - Rank(root[lson] , x - 1 , lson) ;
return GetRank(rson , mid + 1 , r , x , y , v) + ans ;
}
}
int The_Kth(int id , int l , int r , int x , int y , int k) {
if (l == r) return l ;
int ans = Rank(root[lson] , y , lson) - Rank(root[lson] , x - 1 , lson) ;
if (ans >= k) return The_Kth(lson , l , mid , x , y , k) ;
else return The_Kth(rson , mid + 1 , r , x , y , k - ans) ;
}
void Delete_Tree(int id , int l , int r , int x , int v) {
Delete(root[id] , v , id) ;
if (l == r) return ;
if (x <= mid) Delete_Tree(lson , l , mid , x , v) ;
else Delete_Tree(rson , mid + 1 , r , x , v) ;
}
int Precursor(int id , int l , int r , int x , int y , int v) {
if (Rank(root[id] , y , id) - Rank(root[id] , x - 1 , id) == 0) return -INF ;
if (l == r && l == v) return -INF ;
if (l == r) return l ;
if (v <= mid) return Precursor(lson , l , mid , x , y , v) ;
else {
int ans = Precursor(rson , mid + 1 , r , x , y , v) ;
if (ans == -INF) return Precursor(lson , l , mid , x , y , v) ;
else return ans ;
}
}
int Subsquent(int id , int l , int r , int x , int y , int v) {
if (Rank(root[id] , y , id) - Rank(root[id] , x - 1 , id) == 0) return INF ;
if (l == r && l == v) return INF ;
if (l == r) return l ;
if (v >= mid + 1) return Subsquent(rson , mid + 1 , r , x , y , v) ;
else {
int ans = Subsquent(lson , l , mid , x , y , v) ;
if (ans == INF) return Subsquent(rson , mid + 1 , r , x , y , v) ;
else return ans ;
}
}
#undef lson
#undef rson
#undef mid
} using namespace SEGMENT_TREE ;
int n , m ; int a[N] , rad , opt ;
signed main() {
#ifndef ONLINE_JUDGE
freopen("1.in" , "r" , stdin) ;
freopen("1.out", "w" ,stdout) ;
#endif
n = read() , m = read() ;
for (int i = 1 ; i <= n ; ++ i) {
a[i] = read() ;
updata(rad , 0 , Size , a[i] , i) ;
}
int x , y , z ; int num = 0 ;
for (int i = 1 ; i <= m ; ++ i) {
opt = read() ; x = read() , y = read() ;
switch (opt) {
case 3 :
Delete_Tree(rad , 0 , Size , a[x] , x) ;
a[x] = y ;
updata(rad , 0 , Size , a[x] , x) ;
break ;
case 1 :
z = read() ;
printf("%lld\n" , GetRank(rad , 0 , Size , x , y , z)) ;
break ;
case 2 :
z = read() ;
printf("%lld\n" , The_Kth(rad , 0 , Size , x , y , z)) ;
break ;
case 4 :
z = read() ;
printf("%lld\n" , Precursor(rad , 0 , Size , x , y , z)) ;
break ;
case 5 :
z = read() ;
printf("%lld\n" , Subsquent(rad , 0 , Size , x , y , z)) ;
break ;
}
}
}
