平衡树学习笔记（二）splay
平衡树的基本思想：
普通的二叉搜索树会因为一些操作失去二叉搜索树的部分性质，而平衡树就是用一些额外的操作来保持二叉搜索树的性质。
一、节点维护的信息：
rt：根节点
tot:节点个数
fa[o]:父节点
ch[o][0/1]：左右子节点的编号
val[o]:节点权值
cnt[o]:权值出现的次数
sz[o]:子树大小
二、基本操作:
✧maintain(x):改变节点位置后，更新节点的sz[o]
tips:通常情况下，只需要maintain(x)和maintain(fa[x]),因为splay树的操作中一般只与x和fa[x]相关
✧get(x):判断节点x是父节点的左儿子还是右儿子
✧clear(x):删除点x
Code
void maintain(int x)
{
sz[x]=sz[ch[x][0]]+sz[ch[x][1]]+cnt[x];
}
bool get(int x)
{
return x==ch[fa[x]][1];
}
void clear(int x)
{
ch[x][0]=ch[x][1]=sz[x]=fa[x]=val[x]=cnt[x]=0;
}
三、旋转操作rotate：
基本思想：为了使splay保持平衡而进行旋转操作，本质是将一个节点上移一个位置
/*
回想一下上一章二叉搜索树中，删除点时需要用子节点上移来代替该节点，就可以用于这个操作，还能使这个操作不再破坏二叉搜索树的平衡*/
旋转的前提：
(1)保证整棵splay的中序遍历不变（保持其平衡性质）
(2)保证所有点在改变位置之后维护的信息依然正确且有效
(3)root必须指向旋转之后得到的根节点
旋转分为两种：左旋和右旋
右旋：将节点x的左节点向上移一个位置，用以取代x
左旋：将节点x的右节点向上移一个位置，用以取代x
依旧使分类讨论完成旋转操作：
设要旋转的节点为x，其父节点为y
(1)若x为y的右儿子：
<1>将y的左儿子指向x的右儿子（如果x有右儿子），将x的右儿子的父亲指向y
<2>将x的右儿子指向y，将y的父亲指向x
<3>若原先的y有父节点z，则将x的父节点指向z，将z的y原先的节点位置指向x
(2)若x为y的左儿子：
<1>将y的右儿子指向x的左儿子（如果x有左儿子），将x的左儿子的父亲指向y
<2>将x的左儿子指向y，将y的父亲指向x
<3>若原先的y的父节点z，则将x的父节点指向z,将z的y的原先的节点位置指向x
经过观察，很容易发现，两种情况可以合为一种写法
还记得之前的get()操作吗，这里就可以用这个操作来用xor完成左右节点的左右横跳变化
那么就来描述一下合并两种情况之后的rotate：
op1:将x的一个子节点变为y的一个子节点
op2:将y变为x的子节点
tips:
op3:将y原先的父节点变为x的父节点
Code
void rotate(int x)
{
int y=fa[x],z=fa[y],chk=get(x);
ch[y][chk]=ch[x][chk^1];
if(ch[x][chk^1]) fa[ch[x][chk^1]]=y;
ch[x][chk^1]=y;
fa[y]=x;
fa[x]=z;
if(z) ch[z][y==ch[z][1]]=x;
maintain(y);
maintain(x);//这里一定要先更新y再更新x，因为此时y是x的子节点，y的所有量都会影响x
}
tips:很显然，rotate有以下性质：
<1>无论左旋还是右旋，都可以发现，rotate(x)之后，x的与x类型(指是左节点还是右节点)相同的子节点，仍为x的子节点，且该节点的节点类型不变。
<2>左旋或右旋之后，x的与x类型不同的子节点成为了原先x的父节点y的子节点，且节点类型发生了改变（如右旋之后，x的右儿子变成了y的左儿子）。
有一个记忆技巧就是：x的外侧节点不变，内侧节点变为y
三、伸展操作splay：
基本思想：每访问一个节点x后都要将其旋转到根节点
除了maintain、clear、get操作，其他的操作，每一次都要将最终答案splay到根节点
分为6种情况，但是由于rotate的分类方式，所以splay也可以用一个函数处理六种情况
具体内容可以去往OIWIKI
大意就是：
(1)若x的父节点为根节点，则直接左旋或右旋一次x即可
(2)若x的父节点不为根节点。
<1>若x的类型与x的父节点相同，则先将其父亲左旋或右旋，再将x左旋或右旋。
<2>若x的类型与x的父节点不同，则直接两次左旋或右旋x即可。
Code
void splay(int x)
{
for(int f=fa[x];f=fa[x],f;rotate(x))
if(fa[f]) rotate(get(x)==get(f) ? f : x);
rt=x;
}
简单想一下就会发现这个写法很完美地包含了上面六种情况。
由于x一定会被上旋一次，因此需要讨论的问题只有第一次是上旋fa[x]还是上旋x。
✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧
以下的操作一定要记住一点：splay具有全部二叉搜索树的性质
五、插入元素操作insert：
不说了，还是分情况讨论：
(1)整个树为空，新建根节点就完事了，不需要splay
(2)树不为空，则从节点向下找。
✧✧✧✧✧<1>找到k，则修改节点信息，splay即可
✧✧✧✧✧<2>如果k不存在，则新建一个点，splay
Code
void insert(int k)
{
if(!rt)
{
cnt[++tot]=1;
val[tot]=1;
rt=tot;
maintain(tot);
return;
}
while(1)
{
int cur=rt,f=0;
if(val[cur]==k)
{
cnt[cur]++;
maintain(cur);
maintain(cur);
maintain(f);
splay(x);
return;
}
f=cur;
cur=ch[f][val[cur]<k];
if(!cur)
{
val[++tot]=k;
cnt[tot]=1;
fa[tot]=f;
ch[f][val[f]<k]=tot;
maintain(tot);
maintain(f);
splay(tot);
}
if(!cur)
}
}
六、查询k的排名：
灵活运用二叉搜索树的性质即可：
k的排名的定义：严格小于k的数的数量+1
Code
int queryrk(int k)
{
int res=0,cur=rt;
while(1)
{
if(k<val[cur]) cur=ch[cur][0];
else
{
res+=sz[ch[cur][0]];
if(val[cur]==k)
{
splay(cur);
return res+1;
}
res+=cnt[cur];
cur=ch[cur][1];
}
}
}
和上一个操作差不多，不过有时候会出现k并不存在与平衡树中的情况。
此时如果直接查询就会RE。
所以我们有两种解决方式：
(1)把函数写法改成不需要严格相等
(2)先insert(x),然后查询，再del(x）。（这里借用了查询前驱的技巧，和删除操作，这两个操作都会在后面被提及）
六、查询排名为k的数：
啊又是二叉搜索树性质的运用
排名吗，不会出现什么太奇怪的问题。
但是要保证k<=tot,否则肯定无解。
Code
int kth(int k)
{
int cur=rt;
while(1)
{
if(k<=sz[ch[cur][0]]) cur=ch[cur][0];
else
{
k-=cnt[cur]+sz[ch[cur][0];
if(k<=0)
{
splay(cur);
return val[cur];
}
cur=sz[ch[cur][1]];
}
}
}
七、查询x的前驱：
前驱的定义：小于x的最大的数
因此根据定义，x的前驱是x的左子树的右链顶点。
查询前驱之前需要先insert(x),然后再找到x左子树的右链顶点，最后del(x)删除x。
tips1:函数返回的是x的前驱所在的点的编号
tips2:如果不存在x的前驱，函数pre（）会返回0，因此无解也不会出现RE的情况
Code
int pre()
{
int cur=ch[rt][0];
if(!cur) return cur;
while(ch[cur][1]) cur=ch[cur][1];
splay(cur);
return cur;
}
八、查询x的后继：
和上面完全同理
后继的定义：大于x的最小的数
直接insert(x),找到x的右子树的左链顶点，然后del(x)即可。
int nxt()
{
int cur=ch[rt][1];
if(!cur) return cur;
while(ch[cur][1]) cur=ch[cur][1];
splay(cur);
return cur;
}
九、合并两棵splay树：
设两棵树的根节点分别为x，y,在合并操作中，规定x树中的最大值小于y树中的最小值。（维护splay树的性质）
(1)若其中一棵树为空树或者两棵树都是空树，那么直接设rt=非空的树的根或者rt=0即可
(2)若两棵树均不为空树，则将x的最大值splay到根，将x的右子树设置成y并更新节点信息，最终返回节点x即可。
tips：合并操作中"x树中的最大值小于y树中的最小值"是合并的前提条件，而不是因为上述操作而成立的。
因此合并操作之前需要已知上述条件成立，或者通过重构或者其他操作使得上述条件成立。
十、删除x的操作：
这不是一个核心操作，确实最难写的操作
步骤：
(1)将k splay到根（进行该操作后val[rt]==k）
(2)判断cnt[k]:
✧✧✧✧✧<1>若cnt[k]>1，直接cnt[k]--即可
✧✧✧✧✧<2>若cnt[k]=1,分情况讨论，合并rt的两棵子树
✧✧✧✧✧✧✧✧✧✧{1}左右子树均为空树，clear(rt)
✧✧✧✧✧✧✧✧✧✧{2}左右子树中有一棵子树为空树：clear（rt),rt=ch[rt][1/0]
✧✧✧✧✧✧✧✧✧✧{3}左右子树均不为空树：由于这两棵子树是rt的左右子树，一定满足合并两颗splay的条件，因此按上述操作合并即可
Code
void del(int k)
{
queryrnk(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][1])
{
int cur=rt;
rt=ch[rt][0];
fa[rt]=0;
clear(cur);
return;
}
if(!ch[rt][0])
{
int cur=rt;
rt=ch[rt][1];
fa[rt]=0;
clear(cur);
return;
}
int cur=rt,x=pre();//此时k在根节点的位置上，找pre()找到的是rt的左子树中的最大值
fa[ch[cur][1]]=x;
ch[x][1]=ch[cur][1];
clear(cur);
maintain(cur);
}
✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧✧
完结撒花！
才没完事呢！
让我们把代码合起来：
来几道题：https://www.luogu.com.cn/problem/P6136
其实和普通平衡树没什么关系，只是强制在线卡其他奇怪的离线做法。
题解代码
Code
#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+1e5+50;
int fa[maxn],sz[maxn],ch[maxn][4],tot,val[maxn],cnt[maxn],rt;
void maintain(int x)
{
sz[x]=sz[ch[x][0]]+sz[ch[x][1]]+cnt[x];
}
bool get(int x)
{
return ch[fa[x]][1]==x;
}
void clear(int x)
{
sz[x]=fa[x]=ch[x][0]=ch[x][1]=val[x]=cnt[x]=0;
}
void rotate(int x)
{
int y=fa[x],z=fa[y],chk=get(x);
ch[y][chk]=ch[x][chk^1];
if(ch[x][chk^1]) fa[ch[x][chk^1]]=y;
ch[x][chk^1]=y;
fa[x]=z;
fa[y]=x;
if(z) ch[z][ch[z][1]==y]=x;
maintain(y);
maintain(x);
}
void splay(int x)
{
for(int f=fa[x];f=fa[x],f;rotate(x))
{
if(fa[f]) rotate(get(x)==get(f) ? f : x);
}
rt=x;
}
void insert(int k)
{
if(!rt)
{
cnt[++tot]=1;
val[tot]=k;
rt=tot;
maintain(rt);
return;
}
int f=0,cur=rt;
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)
{
fa[++tot]=f;
ch[f][val[f]<k]=tot;
cnt[tot]=1;
val[tot]=k;
maintain(tot);
maintain(f);
splay(tot);
break;
}
}
}
int queryrnk(int k)
{
int res=0,cur=rt;
while(1)
{
if(k<val[cur]) cur=ch[cur][0];
else
{
res+=sz[ch[cur][0]];
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(k<=sz[ch[cur][0]])
{
cur=ch[cur][0];
}
else
{
k-=cnt[cur]+sz[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 nxt()
{
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)
{
queryrnk(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,x=pre();
fa[ch[cur][1]]=x;
ch[x][1]=ch[cur][1];
clear(cur);
maintain(rt);
}
int main()
{
// freopen("splay.in","r",stdin);
// freopen("splay.out","w",stdout);
int n,m,last=0,sum=0;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i)
{
int x;
scanf("%d",&x);
insert(x);
}
for(int i=1;i<=m;++i)
{
int opt,x;
scanf("%d%d",&opt,&x);
x^=last;
if(opt==1) insert(x);
if(opt==2) del(x);
if(opt==3)
{
insert(x);
last=queryrnk(x);
del(x);
sum^=last;
}
if(opt==4)
{
last=kth(x);
sum^=last;
}
if(opt==5)
{
insert(x);
last=val[pre()];
sum^=last;
del(x);
}
if(opt==6)
{
insert(x);
last=val[nxt()];
sum^=last;
del(x);
}
}
printf("%d",sum);
return 0;
}
这次真的结束了。BYE~
