在洛谷3369 Treap模板题 中发现的Splay详解

Posted five20

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了在洛谷3369 Treap模板题 中发现的Splay详解相关的知识,希望对你有一定的参考价值。

本题的Splay写法(无指针Splay超详细)

前言

首先来讲。。。终于调出来了55555。。。调了整整3天。。。。。

看到大部分大佬都是用指针来实现的Splay。小的只是按照Splay的核心思想和原理来进行的。可能会有不妥之处,还请大佬们指出,谢谢!

那么这个题解存在的意义就是让不会敲Splay的人额。。。会敲Splay啦。。。

基本思想

数据结构

对于Splay,我定义了一个class类(当成struct就行啦。。。个人习惯不同啦),定义名称为“Splay”。

之后在类中,我定义了Splay的主体,即数组e。

e的类型是node类型,包含节点值(v)、父级节点(father)、左孩子(ch[0])、右孩子(ch[1])、包含自己在内的下面共有多少元素(sum)(注意是元素啊!!!不是节点!!!)、该节点所表示的元素出现的次数(recy)。

之后,还在类中定义了n代表当前已经使用的数组编号。points代表整个树总共有多少元素(注意是元素啊!!!不是节点!!!)。

另外,整棵树中,有一个超级根e[0],其右孩子即为树的根。

宏定义了e[0].ch[1]为root,方便访问、理解。并在类的末尾取消定义root,确保外部再定义root变量时不会出现问题,维持其模块性质。

class Splay//存储规则:小左大右,重复节点记录 
{
    #define root e[0].ch[1]   //该树的根节点
    private:
        class node
        {
            public:
                int v,father;//节点值,父级节点 
                int ch[2];//左孩子=0,右孩子=1
                int sum;//自己+自己下级有多少节点。在根节点为1。
                int recy;//记录自己被重复了几次
        };        
node e[MAXL];//Splay树主体
        int n,points;//使用存储数,元素数
    ……
    #undef root
};

功能全解

更新当前节点sum值(update)

就是在进行了连接、插入、删除等操作以后使用的一个维护性质的函数。用来确定被update的节点的sum值。

void update(int x)
{
    e[x].sum=e[e[x].ch[0]].sum+e[e[x].ch[1]].sum+e[x].recy;
}

获取父子关系(identify)

用来确定当前节点到底是父亲的左孩子(0)还是右孩子(1)。

int identify(int x)
{
    return e[e[x].father].ch[0]==x?0:1;
}

建立父子关系(connect)

用来连接两个点,其中一个点为另一个点的孩子。

注意,这个操作并不能将其他的父子关系一并断开。因为他们与被操作的两个点没有直接的数据联系。例如下图:

技术分享图片

 

图表明尽管B的父亲已经不是x,但是x的右孩子依旧是B,没有被更新。因此使用过程中应当有更巧妙的设计来避免这样导致的错误发生。

void connect(int x,int f,int son)//连接函数。用法:connect(son,father,左儿子(0)或右儿子(1))
{
    e[x].father=f;
    e[f].ch[son]=x;
}//作用:将x连接在f的下方。连接方向由son的值决定。

旋转节点(rotate)

着重注意的一个函数。这个函数同时实现了左旋和右旋。

所谓的旋转,其实就是指将被指定的节点向上移动一级,并将原有的父级节点作为自己的儿子。如下图:

技术分享图片

 

我们可以通过下图原理论证来确定只需要三次connect即可完成旋转。

技术分享图片

 

上图代表了右旋。

在图中,A、B、C代表三个子树(可以是空的),x和y代表被旋转的节点。R为y的上级节点,与旋转没有直接关系,但是它的右孩子要进行相应的改变。

在进行完connect函数后,再进行update函数即可完成旋转。

但是旋转总共有两种类型的操作(即左旋和右旋)。在这里,我们需要配合位运算直接达到自动判断和旋转方向决断的目的。

我们知道,对于任意一个自然数,与1进行逻辑异或运算,会得到这样的结果:

0^1=1 1^1=0 2^1=3 3^1=2 4^1=5 5^1=4 ……

也就是说,0对应1,2对应3,4对应5,向后依次推。

既然这样,那么我们的左右儿子节点所代表的编号分别是0和1。也就是说对其中一个取逻辑异或,会得到另一个儿子的标号(即对0取逻辑异或得1,对1取逻辑异或得0)。

通过左旋右旋的性质可以知道,实际改变了父子关系的节点是上图的:x、y、B节点。因为实际上,A、C节点的父子关系并没有发生任何改变。

并且我们能够注意到,x与y节点的连接方向一定是与x和B的连接方向不同的。

那么,我们只需要先通过“identify”函数确定x与y的父子关系,确定到底要向那一边旋转(如果x是y的左孩子,那么就向右旋转。如果x是y的右孩子,那么就向左旋转),然后通过逻辑异或来确定子树“B”究竟应当被连接在y的哪一侧。

void rotate(int x)
{
    int y=e[x].father;
    int mroot=e[y].father;
    int mrootson=identify(y);
    int yson=identify(x);
    int B=e[x].ch[yson^1];
    connect(B,y,yson);connect(y,x,(yson^1));connect(x,mroot,mrootson);
    update(y);update(x);
}

伸展操作(Splay)

其实就是考虑上旋节点的方式。

在这里,一开始我使用了一种较为偷懒的旋转方式,即能向上旋转就向上旋转。并不考虑上面的状况到底怎样。

其实,标准的写法中,需要考虑两种情况。如下图:

技术分享图片

 

为了防止造成误导,我将不再介绍直接上旋的操作。但事实上,无论是直接上旋还是先判断再上旋,都会有可能进化或者退化原本的树形结构。

我也曾举出过两种操作模式各自进化或者退化树的例子。但是根据交题情况,在洛谷的模板题中,直接上旋的速度更快。然而在湖南的一道省选题中,使用直接上旋的模式却直接导致超时(大概慢了10倍)。所以说在面对大数据的不确定因素下,还是应当选择考虑更多种情况,而不能图方便。

在这里,我的函数实现的操作是:将at节点旋转到to节点所在的位置。

void splay(int at,int to)
{
    to=e[to].father;
    while(e[at].father!=to)
    {
        int up=e[at].father;
        if(e[up].father==to) rotate(at);
        else if(identify(up)==identify(at))
        {//对应图中case1
            rotate(up);
            rotate(at);
        }
        else
        {//对应图中case2
            rotate(at);
            rotate(at);
        }
    }
}

添加节点(crepoint)和摧毁节点(destroy)

这两个操作是在插入新元素和删除元素过程中使用的函数。

crepoint的作用是获得一个新的树存储位置,然后为这个存储空间写入基本的信息,并返回使用的存储位置编号。

destroy的作用则是使得一个节点完全失效,完全抹除节点信息,防止其他意外的发生。并且添加了一个小小的优化:如果被抹除的节点恰好是存储数组的当前最后一个元素,那么就对存储空间的使用数减1。

实际上,也可以通过一个队列来确定那些节点在中间被挖空了。但这样的操作不仅要牺牲一个O(log N)的时间复杂度,而且事实上并没有太大的用处,因为你开的数组大小一定能够满足极端情况(比如说所有操作都是插入)。

int crepoint(int v,int father)
{
    n++;
    e[n].v=v;
    e[n].father=father;
    e[n].sum=e[n].recy=1;
    return n;
}
void destroy(int x) 
{
    e[x].v=e[x].ch[0]=e[x].ch[1]=e[x].sum=e[x].father=e[x].recy=0;
    if(x==n) n--;
}

查找元素(find)

要实现的功能是找特定值是否在树中以及对应的节点编号。

很简单的实现方式。从根开始向下移动,如果要找的元素比当前节点小,那么就转到自己的左孩子。否则,就转向自己的右孩子,直到节点值等于要找的值。

如果在找到目标值之前,需要走的路已经无法再走(比如说现在到了5,要找的是3,应该往左走,但是5已经没有左孩子了),那么则查找失败,返回失败值(0)。如果查找成功,则返回节点对应的编号。

查找结束后,将被查找的节点旋转到根,以保证树的结构随机性。

int find(int v) 
{
    int now=root;
    while(true)
    {
        if(e[now].v==v)
        {
            splay(now,root);
            return now;
        }
        int next=v<e[now].v?0:1;
        if(!e[now].ch[next]) return 0;
        now=e[now].ch[next];
    }
}

建树(build)

建树的功能我并没有看懂大佬们的操作到底是什么意思。。。(我觉得应该是将Splay用作线段树的时候使用的功能)所以我写了一个没有上旋操作的insert函数。

首先,从根开始,向下寻找。如果要插入的元素已经在树中,那么将这个节点的recy加1即可。如果没有出现过,那么找一个合适的空的位置。找到位置后,调用crepoint函数,在数组中申请一个新的下标存储元素。

同时注意,在向下寻找的过程中,对被经过的点的sum值加1,因为如果经过这个点,代表要加的点肯定在自己下面,所以自己下面的元素个数加1。

int build(int v)//内部调用的插入函数,没有splay 
{
    points++;
    if(n==0)//特判无点状态 
    {
        root=1;
        crepoint(v,0);
    }
    else
    {
        int now=root;
        while(true)//向下找到一个空节点 
        {
            e[now].sum++;//自己的下级肯定增加了一个节点 
            if(v==e[now].v)
            {
                e[now].recy++;
                return now;
            }
            int next=v<e[now].v?0:1;
            if(!e[now].ch[next])
            {
                crepoint(v,now);
                e[now].ch[next]=n;
                return n;
            }
            now=e[now].ch[next];
        }
    }
    return 0;
}

插入节点(push)

就是在进行完build操作以后,执行一次上旋操作,确保树的结构随机性。

void push(int v)
{
    int add=build(v);
    splay(add,root);
}

删除节点(pop)

将输入值对应的节点在树中移除。

进行这样的操作时,我一开始考虑的是通过逐层的rotate操作将要被删除的节点转到最下方,然后再删除,最后逐层向上改变路径上的sum值。但是考虑到这样的操作可能会一方面导致树的大幅度退化,另一方面相当于要进行两次O(log N)的时间复杂度操作,常数略大,可能会成为一颗定时炸弹。所以为了稳定,还是用了常规的方法:

首先将要删除的节点旋转到根节点的位置。

然后,判断情况:如果要被删除的节点(注意现在它在根的位置)没有左孩子,那么直接摧毁这个节点,并将它的右孩子变成根。

如果自己有左孩子,那么就先把左子树中值最大的元素旋转到根的左孩子位置,然后将根节点的右孩子变成根节点的左孩子的右孩子,然后摧毁节点,并将左孩子变成根。

原理还请读者自己考虑吧,根据二叉排序树的性质。。。

void pop(int v)//删除节点 
{
    int deal=find(v);
    if(!deal) return;
    points--;
    if(e[deal].recy>1)
    {
        e[deal].recy--;
        e[deal].sum--;
        return;
    }
    if(!e[deal].ch[0])
    {
        root=e[deal].ch[1];
        e[root].father=0;
    }
    else
    {
        int lef=e[deal].ch[0];
        while(e[lef].ch[1]) lef=e[lef].ch[1];
        splay(lef,e[deal].ch[0]);
        int rig=e[deal].ch[1];
        connect(rig,lef,1);connect(lef,0,1);
        update(lef);
    }
    destroy(deal);
}

获取元素的排名(rank)&获取该排名对应的元素值(atrank)

两个函数是互逆的函数。

rank的实现根find差不多,只是在向下走的时候,对于当前已经记录的rank值进行更新(每次调用rank时都初始化为0)。规则是:向左走时,rank值不发生任何改变。向右走之前,要先给rank加上当前节点的左孩子的sum值和recy值。找到对应元素时,再对rank+1。如下图:

技术分享图片

 

atrank函数根rank实现完全相反。在向下走的过程中,如果要找的排名大于当前点左子树的sum值,并且小于等于当前点的左子树的sum加上本节点的recy的值,那么当前的点就是要找的点。如果小于上述范围,就往左走,反之向右。注意向右走的过程中,将要查询的排名值减少上述范围的最大值。

两个操作结束后,都要将被操作的节点旋转到根。

int rank(int v)//获取值为v的元素在这棵树里是第几小 
{
    int ans=0,now=root;
    while(true)
    {
        if(e[now].v==v) return ans+e[e[now].ch[0]].sum+1;
        if(now==0) return 0;
        if(v<e[now].v) now=e[now].ch[0];
        else
        {
            ans=ans+e[e[now].ch[0]].sum+e[now].recy;
            now=e[now].ch[1];
        }
    }
    if(now) splay(now,root);
    return 0;
}
int atrank(int x)//获取第x小的元素的值 
{
    if(x>points) return -INF;
    int now=root;
    while(true)
    {
        int minused=e[now].sum-e[e[now].ch[1]].sum;
        if(x>e[e[now].ch[0]].sum&&x<=minused) break;
        if(x<minused) now=e[now].ch[0];
        else
        {
            x=x-minused;
            now=e[now].ch[1];
        }
    }
    splay(now,root);
    return e[now].v;
}

查找前驱(lower)和后继(upper)

两种操作是类似的操作。

前驱是指在树中,小于这个值并且最接近这个值的元素值。

后继则是大于这个值并且最接近这个值的元素值。

对于这两种函数的实现方式,就是先初始化一个最值,然后在向下走的过程中,如果发现了符合要求且更优的值,就用更优值替换当前的值。最后不能走的时候输出这个值即可。

int upper(int v) 
{
    int now=root;
    int result=INF;
    while(now)
    {
        if(e[now].v>v&&e[now].v<result) result=e[now].v;
        if(v<e[now].v) now=e[now].ch[0];
        else now=e[now].ch[1];
    }
    return result;
}
int lower(int v) 
{
    int now=root;
    int result=-INF;
    while(now)
    {
        if(e[now].v<v&&e[now].v>result) result=e[now].v;
        if(v>e[now].v) now=e[now].ch[1];
        else now=e[now].ch[0];
    }
    return result;
}

完整源代码

下面贴出完整源代码,方便交流分享!

 

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<algorithm>
  4 using namespace std;
  5 
  6 const int MAXL=100005;
  7 const int INF=2147480000;
  8 
  9 class Splay//存储规则:小左大右,重复节点记录 
 10 {
 11     #define root e[0].ch[1]   //该树的根节点
 12     private:
 13         class node
 14         {
 15             public:
 16                 int v,father;//节点值,父级节点 
 17                 int ch[2];//左孩子=0,右孩子=1
 18                 int sum;//自己+自己下级有多少节点。在根节点为1。
 19                 int recy;//记录自己被重复了几次
 20         };
 21         node e[MAXL];//Splay树主体
 22         int n,points;//使用存储数,元素数
 23         void update(int x)
 24         {
 25             e[x].sum=e[e[x].ch[0]].sum+e[e[x].ch[1]].sum+e[x].recy;
 26         }
 27         int identify(int x)
 28         {
 29             return e[e[x].father].ch[0]==x?0:1;
 30         }
 31         void connect(int x,int f,int son)//连接函数。用法:connect(son,father,1/0)
 32         {
 33             e[x].father=f;
 34             e[f].ch[son]=x;
 35         }//作用:使得x的father=f,f的son=x.
 36         void rotate(int x)
 37         {
 38             int y=e[x].father;
 39             int mroot=e[y].father;
 40             int mrootson=identify(y);
 41             int yson=identify(x);
 42             int B=e[x].ch[yson^1];
 43             connect(B,y,yson);connect(y,x,(yson^1));connect(x,mroot,mrootson);
 44             update(y);update(x);
 45         }
 46         void splay(int at,int to)//将at位置的节点移动到to位置
 47         {
 48             to=e[to].father;
 49             while(e[at].father!=to)
 50             {
 51                 int up=e[at].father;
 52                 if(e[up].father==to) rotate(at);
 53                 else if(identify(up)==identify(at))
 54                 {
 55                     rotate(up);
 56                     rotate(at);
 57                 }
 58                 else
 59                 {
 60                     rotate(at);
 61                     rotate(at);
 62                 }
 63             }
 64         }
 65         int crepoint(int v,int father)
 66         {
 67             n++;
 68             e[n].v=v;
 69             e[n].father=father;
 70             e[n].sum=e[n].recy=1;
 71             return n;
 72         }
 73         void destroy(int x)//pop后摧毁节点 
 74         {
 75             e[x].v=e[x].ch[0]=e[x].ch[1]=e[x].sum=e[x].father=e[x].recy=0;
 76             if(x==n) n--;//最大限度优化
 77         }
 78     public:
 79         int getroot(){return root;}
 80         int find(int v)//用于外部的find调用
 81         {
 82             int now=root;
 83             while(true)
 84             {
 85                 if(e[now].v==v)
 86                 {
 87                     splay(now,root);
 88                     return now;
 89                 }
 90                 int next=v<e[now].v?0:1;
 91                 if(!e[now].ch[next]) return 0;
 92                 now=e[now].ch[next];
 93             }
 94         }
 95         int build(int v)//内部调用的插入函数,没有splay 
 96         {
 97             points++;
 98             if(n==0)//特判无点状态 
 99             {
100                 root=1;
101                 crepoint(v,0);
102             }
103             else
104             {
105                 int now=root;
106                 while(true)//向下找到一个空节点 
107                 {
108                     e[now].sum++;//自己的下级肯定增加了一个节点 
109                     if(v==e[now].v)
110                     {
111                         e[now].recy++;
112                         return now;
113                     }
114                     int next=v<e[now].v?0:1;
115                     if(!e[now].ch[next])
116                     {
117                         crepoint(v,now);
118                         e[now].ch[next]=n;
119                         return n;
120                     }
121                     now=e[now].ch[next];
122                 }
123             }
124             return 0;
125         }
126         void push(int v)//插入元素时,先添加节点,再进行伸展 
127         {
128             int add=build(v);
129             splay(add,root);
130         }
131         void pop(int v)//删除节点 
132         {
133             int deal=find(v);
134             if(!deal) return;
135             points--;
136             if(e[deal].recy>1)
137             {
138                 e[deal].recy--;
139                 e[deal].sum--;
140                 return;
141             }
142             if(!e[deal].ch[0])
143             {
144                 root=e[deal].ch[1];
145                 e[root].father=0;
146             }
147             else
148             {
149                 int lef=e[deal].ch[0];
150                 while(e[lef].ch[1]) lef=e[lef].ch[1];
151                 splay(lef,e[deal].ch[0]);
152                 int rig=e[deal].ch[1];
153                 connect(rig,lef,1);connect(lef,0,1);
154                 update(lef);
155             }
156             destroy(deal);
157         }
158         int rank(int v)//获取值为v的元素在这棵树里是第几小 
159         {
160             int ans=0,now=root;
161             while(true)
162             {
163                 if(e[now].v==v) return ans+e[e[now].ch[0]].sum+1;
164                 if(now==0) return 0;
165                 if(v<e[now].v) now=e[now].ch[0];
166                 else
167                 {
168                     ans=ans+e[e[now].ch[0]].sum+e[now].recy;
169                     now=e[now].ch[1];
170                 }
171             }
172             if(now) splay(now,root);
173             return 0;
174         }
175         int atrank(int x)//获取第x小的元素的值 
176         {
177             if(x>points) return -INF;
178             int now=root;
179             while(true)
180             {
181                 int minused=e[now].sum-e[e[now].ch[1]].sum;
182                 if(x>e[e[now].ch[0]].sum&&x<=minused) break;
183                 if(x<minused) now=e[now].ch[0];
184                 else
185                 {
186                     x=x-minused;
187                     now=e[now].ch[1];
188                 }
189             }
190             splay(now,root);
191             return e[now].v;
192         }
193         int upper(int v)//寻找该值对应的一个最近的上界值 
194         {
195             int now=root;
196             int result=INF;
197             while(now)
198             {
199                 if(e[now].v>v&&e[now].v<result) result=e[now].v;
200                 if(v<e[now].v) now=e[now].ch[0];
201                 else now=e[now].ch[1];
202             }
203             return result;
204         }
205         int lower(int v)//寻找该值对应的一个最近的下界值 
206         {
207             int now=root;
208             int result=-INF;
209             while(now)
210             {
211                 if(e[now].v<v&&e[now].v>result) result=e[now].v;
212                 if(v>e[now].v) now=e[now].ch[1];
213                 else now=e[now].ch[0];
214             }
215             return result;
216         }
217     #undef root
218 };
219 Splay F;
220 
221 int main()
222 {
223 
224     return 0;
225 }

 

 

后记

总算是讲完了如何实现最基础的Splay排序树。

可能会有大佬感觉:明明是来做题的了,怎么会有不懂Splay的呢?这不纯粹是装逼么?而且一点水平也没有,纯粹瞎扯淡!

我只能说,我刚开始学Splay的时候,就是一点一点的寻找相关资料的。包括从这道模板题找。但是系统讲解的还真没多少。而且贴出来的示例代码比较复杂,表示弱鸡看不懂。。。所以在钻研以后,写下了这篇文章。这些是我对Splay的理解。我将他们变成了书面的东西去分享给大家,希望大家能够从中受益,希望能够帮到更多正在努力学习平衡树的OIERS。如果有问题,也可以提出来,帮助我改进。

以上是关于在洛谷3369 Treap模板题 中发现的Splay详解的主要内容,如果未能解决你的问题,请参考以下文章

[模板]洛谷T3369 普通平衡树 链表&普通Treap

洛谷 P3369 模板普通平衡树(Treap/SBT)

洛谷 P3369 BZOJ 3224 模板普通平衡树(Treap/SBT)

[模板]洛谷T3369 普通平衡树 链表&递归版无父指针版Splay

P3369 模板普通平衡树(Treap/SBT)

luoguP3369[模板]普通平衡树(Treap/SBT) 题解