关于Splay的学习感受
【关于Splay】
之前记得五月份听过一次外省金牌选手讲过一次，然后七月份又讲过一次，但本人脑子比较笨，当时完全听得一脸懵逼啊，练了两个月确实不一样，现在谈一下学习Splay的一些感受。
首先欲知Splay为何物，不得不先讲讲它的祖宗：二叉查找树，即BST（Binary Search Tree），关于二叉查找树，它不是一颗空树就是拥有以下几个性质的二叉树：
1.树中每个结点被赋予了一个权值；（下面假设不同结点的权值互不相同。）
2.若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
3.若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
4.左、右子树也分别为二叉查找树；
下图就是一个合法的BST（蜜汁画风【捂脸】）：
通常二叉查找树支持如下操作：查找一个元素x在集合中是否存在；插入或删除一个元素，这些都可以通过递归实现。
但这也有个小问题，每个操作的复杂度都取决于树的高度，那么当这棵树退化成一条链的时候，复杂度就退化成O(n)的了，由于二叉查找树的形态不一，所以平衡树就出现了，它的每种操作最坏情况、均摊、期望的时间复杂度就是O(log n)的。而常用平衡树有两种：Splay和Treap，这里介绍Splay，下一篇文章介绍Treap。
（废话一堆然后转入正题）
Splay，即伸展树，是二叉查找树的一种改进，它与二叉查找树性质相似，与其不同的就是它可以自我调整。
关于Splay操作：伸展操作 Splay(x, S)是在保持伸展树有序性的前提下，通过一系列旋转将伸展树 S 中的元素 x调整至树的根部。在调整的过程中，要分以下三种情况分别处理：这个东西常数不能靠谱的可持久化，所以比起Treap而言，Splay的优势似乎仅在于求LCT。
1.节点x的父节点y是根节点：如果x是左儿子，那么就右旋一下，如果是右儿子，那么就左旋一下，一次操作后，x就变成根节点了，完成，下面是示意图：
2.节点x的父节点y不是根节点，y的父节点为z，且x,y均为父节点的左儿子或右儿子，那么就右旋或左旋两次，分别交换y,z和x,y，下面是示意图（灵魂画师再次上线）：
3.节点x的父节点y不是根节点，y的父节点为z，x,y一个是左儿子，一个是右儿子，这时如果x是左儿子就先右旋再左旋，如果是右儿子就先左旋再右旋，注意两次都是转x，示意图：
所以由上图可以感性理解一下，经旋转的平衡树确实比之前要平衡很多，注意每次操作后都要进行伸展操作，然后这样下来各操作复杂度均摊为O(log n)（因为不会证所以我就直接跳了）。
Splay支持以下操作：
1.Find(x,S)：判断元素x是否在伸展树S表示的有序集中。首先，访问根节点，如果x比根节点权值小则访问左儿子；如果x比根节点权值大则访问右儿子；如果权值相等，则说明x在树中；如果访问到空节点，则x不在树中。如果x在树中，则再执行Splay(x,S)调整伸展树。
2.Insert(x,S)：将元素x插入伸展树S表示的有序集中。首先，访问根节点，如果x比根节点权值小则访问左儿子；如果x比根节点权值大则访问右儿子；如果访问到空节点t,则把x插入该节点，然后执行Splay(t,S)。
3.Merge(S1,S2)：将两个伸展树S1与S2合并成为一个伸展树。其中S1的所有元素都小于S2的所有元素。首先，我们找到伸展树S1中最大的一个元素x，再通过Splay(x,S1)将x调整到伸展树S1的根。然后再将S2作为x节点的右子树。这样，就得到了新的伸展树S。如图所示：
4.Delete(x,S)：把节点x从伸展树表示的有序集中删除。首先，执行Splay(x,S)将x旋转至根节点。然后取出x的左子树S1和右子树S2，执行Merge(S1,S2)把两棵子树合并成S。如图所示：
5.Split(x,S)：以x为界，将伸展树S分离为两棵伸展树S1和S2，其中S1中所有元素都小于x，S2中的所有元素都大于x。首先执行Find(x,S)，将元素x调整为伸展树的根节点，则x的左子树就是S1，而右子树为S2。图示同上。
除了以上操作，Splay还支持求最大值、最小值、前驱后继，同时，Splay还能进行区间操作，对于待操作区间[l,r]，我们将l-1通过Splay旋至根节点处，再将r+1旋至根节点右儿子处，这时r+1的左儿子就是待操作区间，可以像线段树那样打lazy-tag标记，然后具体实现见下方代码（主要给Rotate(左旋右旋合并版，只用打一段即可，不必打一个Zig打一个Zag)，Splay，build，lazy，find(int k)（寻找第k大数）,getnext（求后继，前驱类似））：
（因为从来不打指针所以只能够打打数组）
结构体：
struct Num{ //根据题目不同决定
int val,id;
bool operator<(const Num &a)const{
if(val==a.val)
return id<a.id;
return val<a.val;
}
}So[MAXN/5];
struct Tr{ //平衡树
int fa,sum;
int val,c[2],lz;
}tr[MAXN];
int tot,root,n;1.Rotate:
void Rotate(int x,int k)
{
if(tr[x].fa==-1)
return ;
int fa=tr[x].fa,w;
lazy(fa);
lazy(x);
tr[fa].c[!k]=tr[x].c[k];
if(tr[x].c[k]!=-1)
tr[tr[x].c[k]].fa=fa;
tr[x].fa=tr[fa].fa,tr[x].c[k]=fa;
if(tr[fa].fa!=-1)
{
w=tr[tr[fa].fa].c[1]==fa;
tr[tr[fa].fa].c[w]=x;
}
tr[fa].fa=x;
Push(fa);
Push(x);
}2.Splay
void Splay(int x,int goal)
{
if(x==-1)
return ;
lazy(x);
while(tr[x].fa!=goal)
{
int y=tr[x].fa;
lazy(tr[y].fa);
lazy(y),lazy(x);
bool w=x==tr[y].c[1];
if(tr[y].fa!=goal&&w==(y==tr[tr[y].fa].c[1]))
Rotate(y,!w);
Rotate(x,!w);
}
if(goal==-1)
root=x;
Push(x);
}3.build
int build(int l,int r,int f) //返回根节点
{
if(r<l)
return -1;
int mid=l+r>>1;
int ro=newtr(mid,f,mid);
data[mid]=ro;
tr[ro].c[0]=build(l,mid-1,ro);
tr[ro].c[1]=build(mid+1,r,ro);
Push(ro);
return ro;
}4.lazy
void lazy(int id) //此懒标记表示交换左右儿子，即区间反转
{
if(tr[id].lz)
{
swap(lc,rc);
tr[lc].lz^=1,tr[rc].lz^=1;
tr[id].lz=0;
}
}5.find
int find(int k)
{
int id=root;
while(id!=-1)
{
lazy(id);
int lsum=(lc==-1)?0:tr[lc].sum;
if(lsum>=k)
{
id=lc;
}
else
if(lsum+1==k)
break;
else
{
k=k-lsum-1;
id=rc;
}
}
return id;
}6.getnext
int Getnext(int id)
{
lazy(id);
int p=tr[id].c[1];
if(p==-1)
return id;
lazy(p);
while(tr[p].c[0]!=-1)
{
p=tr[p].c[0];
lazy(p);
}
return p;
}关于Splay，在实现上还有许多细节，如每次操作后的Splay，此处不再赘述。
以上大概是我关于Splay的一些学习总结，以后可能还会填坑【PS：感谢wcr大佬的帮助】
