浅谈splay（双旋）

  • 今天刚刚学习完splay，讲一下自己的想法吧
  • 首先splay和treap不一样，treap通过随机数来调整树的形态。但splay不一样，再每插入或操作一次后，你都会把他旋转到根，再旋转过程中树的形态会不断改变，这样来达到均摊效果 常数据大。
  • 来看看具体实现吧

    首先定义数组，\(size\) 子树大小（包括自己），\(fa\) 节点的父亲，\(key\) 该节点的权值，\(cnt\) 该节点权值出现次数，$ch $表示儿子 0表左二子，1表右儿子

首先看几个简单函数

inline void update(int x)
{
    size[x]=cnt[x]+size[ch[x][0]]+size[ch[x][1]];
}

更新子树大小

inline int get(int x){return x==ch[fa[x]][1];}

返回该节点是left儿子还是right儿子

inline void clear(int x){ch[x][0]=ch[x][1]=fa[x]=size[x]=cnt[x]=key[x]=0;}

删除该节点，清空所有信息

接下来是splay的精髓所在

inline void rotate(int x,int &k)
{
    static int old,oldfa,o;
    old=fa[x];oldfa=fa[old];o=get(x);
    if(old==k)k=x;
    else ch[oldfa][get(old)]=x;
    fa[x]=oldfa;
    ch[old][o]=ch[x][o^1];fa[ch[x][o^1]]=old;
    ch[x][o^1]=old;fa[old]=x;
    update(x),update(old);
}
inline void splay(int x,int &k)
{
    while(x!=k)
    {
        if(fa[x]!=k)rotate(get(x)^get(fa[x])?x:fa[x],k);
        rotate(x,k);
    }
}

rotate，splay，是splay核心操作，显然splay是依赖于rotate的，让我们看一下rotate是如何实现的吧

（手绘图）

我们考虑从图上左往右的过程，我们要将y旋上去，因为y本是x的右儿子，所以x放到y的左儿子，将y的原本左儿子设为x的右儿子，这是左旋，还有对称操作右旋，但我们不必要打两个函数，用 ^可以实现左右儿子的转换，用get操作实现，具体实现参考代码，打代码时最好画个图参照一下。

splay，这个操作完全依靠rotate，目的就是把你要的节点旋转到k（一般是root），k要传地址，要修改。在while循环里加了个小小的优化，但x和他的fa在同一侧时可以旋fa，小小的加速

inline void insert(int x)
{
    if(!root){root=++sz;size[sz]=cnt[sz]=1;key[sz]=x;return;}
    int now=root,o;
    while(1)
    {
        if(x==key[now])
        {
            ++cnt[now];
            splay(now,root);
            update(now);
            return;
        }
        o=x>key[now]?1:0;
        if(!ch[now][o])
        {
            ch[now][o]=++sz;
            size[sz]=cnt[sz]=1;
            key[sz]=x;fa[sz]=now;
            ch[now][o]=sz;
            update(now);
            splay(sz,root);
            return;
        }
        else now=ch[now][o];
    }
}

insert，插入一个数，当没有数时就直接把这个数设为根，else 因为树满足二叉排序树的性质，所以比当前节点的key小就往左走，否则往右走，直到找到一个空节点，更新信息，由于这个点以上所有的点\(size\)都要加一，不好update，所以把这给点旋转到根，将这个点update就行了

inline int find_pos(int x)
{
    int now=root;
    while(1)
    {
        if(x==key[now]){return now;}
        if(x<key[now])now=ch[now][0];
        else now=ch[now][1];
    }
}

找到该值在树中的节点编号

inline int pre()
{
    int now=ch[root][0];
    while(ch[now][1])now=ch[now][1];
    return now;
}
inline int nex()
{
    int now=ch[root][1];
    while(ch[now][0])now=ch[now][0];
    return now;
}

求前驱，后继，前驱从根的左儿子开始一直往右跑，后继从根的右儿子开始一直往左跑即可

void del(int x)
{
    splay(find_pos(x),root);
    if(cnt[root]>1){--cnt[root];return;}
    if(!ch[root][0]&&!ch[root][1]){clear(root);root=0;return;}
    if(ch[root][0]&&ch[root][1])
    {
        int oldroot=root;
        splay(pre(),root);
        fa[ch[oldroot][1]]=root;
        ch[root][1]=ch[oldroot][1];
        clear(oldroot);
        update(root);
    }
    else
    {
        int o=ch[root][1]>0;
        root=ch[root][o];
        clear(fa[root]);
        fa[root]=0;
    }
}

删除操作，有点麻烦，先找到x的位置

  • 如果x有多个就\(cnt\)减一
  • 如果一个儿子都没有就直接删掉，root设为0
  • 如果 只有一个儿子就把儿子设为根，删去这个点
  • 剩下两个儿子情况，找到根的前驱，把前驱旋到根，这是root只有左儿子，再把原来根的右儿子到root上，这样原来的root就脱离了树，再删掉即可。
inline int find_order_of_key(int x)
{
    int res=0,now=root;
    while(1)
    {
        if(x<key[now])now=ch[now][0];
        else
        {
            res+=size[ch[now][0]];
            if(x==key[now]){splay(now,root);return res+1;}
            res+=cnt[now];
            now=ch[now][1];
        }
    }
}
inline int find_by_order(int x)
{
    int now=root;
    while(1)
    {
        if(x<=size[ch[now][0]])now=ch[now][0];
        else
        {
            int temp=size[ch[now][0]]+cnt[now];
            if(x<=temp)return key[now];
            else{x-=temp;now=ch[now][1];}
        }
    }
}

找x的排名，与找排名为x的数，其实大同小异，用二叉搜索树的性质即可，只是记得答案不一样罢了

inline void rever(int l,int r)
{
    l=find(l-1);r=find(r+1);
        splay(l,root);splay(r,ch[l][1]);
        rev[ch[r][0]]^=1;
}

找到区间左边一个和区间的右边一个点在树中位置，把左边的点旋转到根，再把右边的点旋到root的右儿子，这时这段区间一定是ch[r][0]的子树（想一想，为什么）（根据二叉搜索树的性质），把这个点打上标记即可；当遇到有翻转标记的点时，交换其左右子树，并下传标记即可。

ok，splay的基本操作就是这些了

下面是完整代码

洛谷P3369 treap模板

#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=1e5+5;
void cmax(sign &a,sign b){if(a<b)a=b;}
void cmin(sign &a,sign b){if(a>b)a=b;}
template<typename T>T read()
{
    T ans=0,f=1;
    char ch=getchar();
    while(!isdigit(ch)&&ch!=‘-‘)ch=getchar();
    if(ch==‘-‘)f=-1,ch=getchar();
    while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-‘0‘),ch=getchar();
    return ans*f;
}
void file()
{
    #ifndef ONLINE_JUDGE
        freopen("splay.in","r",stdin);
        freopen("splay.out","w",stdout);
    #endif
}
int fa[N],size[N],key[N],cnt[N],ch[N][2],sz,root;
inline void update(int x){size[x]=cnt[x]+size[ch[x][0]]+size[ch[x][1]];}
inline int get(int x){return x==ch[fa[x]][1];}
inline void clear(int x){ch[x][0]=ch[x][1]=fa[x]=size[x]=cnt[x]=key[x]=0;}
inline void rotate(int x,int &k)
{
    static int old,oldfa,o;
    old=fa[x];oldfa=fa[old];o=get(x);
    if(old==k)k=x;
    else ch[oldfa][get(old)]=x;
    fa[x]=oldfa;
    ch[old][o]=ch[x][o^1];fa[ch[x][o^1]]=old;
    ch[x][o^1]=old;fa[old]=x;
    update(x),update(old);
}
inline void splay(int x,int &k)
{
    while(x!=k)
    {
        if(fa[x]!=k)rotate(get(x)^get(fa[x])?x:fa[x],k);
        rotate(x,k);
    }
}
inline void insert(int x)
{
    //puts("");
    if(!root){root=++sz;size[sz]=cnt[sz]=1;key[sz]=x;return;}
    int now=root,o;
    while(1)
    {
        if(x==key[now])
        {
            ++cnt[now];
            splay(now,root);
            update(now);
            return;
        }
        o=x>key[now]?1:0;
        if(!ch[now][o])
        {
            ch[now][o]=++sz;
            size[sz]=cnt[sz]=1;
            key[sz]=x;fa[sz]=now;
            ch[now][o]=sz;
            update(now);
            splay(sz,root);
            return;
        }
        else now=ch[now][o];
        //printf("%d %d %d %d\n",now,fa[now],ch[now][0],ch[now][1]);
    }
}
inline int find_pos(int x)
{
    int now=root;
    while(1)
    {
        if(x==key[now]){return now;}
        if(x<key[now])now=ch[now][0];
        else now=ch[now][1];
    }
}
inline int pre()
{
    int now=ch[root][0];
    while(ch[now][1])now=ch[now][1];
    return now;
}
inline int nex()
{
    int now=ch[root][1];
    while(ch[now][0])now=ch[now][0];
    return now;
}
void del(int x)
{
    splay(find_pos(x),root);
    if(cnt[root]>1){--cnt[root];return;}
    if(!ch[root][0]&&!ch[root][1]){clear(root);root=0;return;}
    if(ch[root][0]&&ch[root][1])
    {
        int oldroot=root;
        splay(pre(),root);
        fa[ch[oldroot][1]]=root;
        ch[root][1]=ch[oldroot][1];
        clear(oldroot);
        update(root);
    }
    else
    {
        int o=ch[root][1]>0;
        root=ch[root][o];
        clear(fa[root]);
        fa[root]=0;
    }
}
inline int find_order_of_key(int x)
{
    int res=0,now=root;
    while(1)
    {
        if(x<key[now])now=ch[now][0];
        else
        {
            res+=size[ch[now][0]];
            if(x==key[now]){splay(now,root);return res+1;}
            res+=cnt[now];
            now=ch[now][1];
        }
    }
}
inline int find_by_order(int x)
{
    int now=root;
    while(1)
    {
        if(x<=size[ch[now][0]])now=ch[now][0];
        else
        {
            int temp=size[ch[now][0]]+cnt[now];
            if(x<=temp)return key[now];
            else{x-=temp;now=ch[now][1];}
        }
    }
}
void input()
{
    int T=read<int>();
    int opt,x;
    while(T--)
    {
        opt=read<int>();x=read<int>();
        if(opt==1)insert(x);
        else if(opt==2)del(x);
        else if(opt==3)printf("%d\n",find_order_of_key(x));
        else if(opt==4)printf("%d\n",find_by_order(x));
        else if(opt==5)
        {
            insert(x);
            printf("%d\n",key[pre()]);
            del(x);
        }
        else if(opt==6)
        {
            insert(x);
            printf("%d\n",key[nex()]);
            del(x);
        }
    }
}
int main()
{
    file();
    input();
    return 0;
}

洛谷P3391 splay模板

#include<bits/stdc++.h>
using namespace std;
typedef int sign;
typedef long long ll;
#define For(i,a,b) for(register sign i=(sign)a;i<=(sign)b;++i)
#define Fordown(i,a,b) for(register sign i=(sign)a;i>=(sign)b;--i)
const int N=1e5+5;
bool cmax(sign &a,sign b){return (a<b)?a=b,1:0;}
bool cmin(sign &a,sign b){return (a>b)?a=b,1:0;}
template<typename T>T read()
{
    T ans=0,f=1;
    char ch=getchar();
    while(!isdigit(ch)&&ch!=‘-‘)ch=getchar();
    if(ch==‘-‘)f=-1,ch=getchar();
    while(isdigit(ch))ans=(ans<<3)+(ans<<1)+(ch-‘0‘),ch=getchar();
    return ans*f;
}
void file()
{
    #ifndef ONLINE_JUDGE
        freopen("splay.in","r",stdin);
        freopen("splay.out","w",stdout);
    #endif
}
int ch[N][2],fa[N],size[N],rev[N],root,sz;
inline int get(int x){return x==ch[fa[x]][1];}
inline void update(int x){size[x]=1+size[ch[x][0]]+size[ch[x][1]];}
inline void rotate(int x,int &k)
{
    int old=fa[x],oldfa=fa[old],o=get(x);
    if(k==old)k=x;
    else ch[oldfa][ch[oldfa][1]==old]=x;
    fa[x]=oldfa;fa[old]=x;fa[ch[x][o^1]]=old;
    ch[old][o]=ch[x][o^1];ch[x][o^1]=old;
    update(x),update(old);
}
inline void splay(int x,int &k)
{
    while(x!=k)
    {
        if(fa[x]!=k)rotate(get(x)^get(fa[x])?x:fa[x],k);
        //printf("%d %d\n",x,k);
        rotate(x,k);
    }
}
#define mid ((l+r)>>1)
inline void build(int l,int r,int pre)
{
    if(l>r)return;
    ch[pre][mid>=pre]=mid;
    fa[mid]=pre;size[mid]=1;
    if(l==r)return;
    build(l,mid-1,mid);build(mid+1,r,mid);
    update(mid);
}
#undef mid
int n,m;
void input(){n=read<int>();m=read<int>();}
inline void rever(int x)
{
    swap(ch[x][0],ch[x][1]);
    rev[ch[x][0]]^=1;rev[ch[x][1]]^=1;
    rev[x]=0;
}
int find(int x)
{
    int now=root;
    while(1)
    {
        if(rev[now])rever(now);
        if(size[ch[now][0]]>=x)now=ch[now][0];
        else
        {
            if(size[ch[now][0]]==x-1)return now;
            x=x-size[ch[now][0]]-1;
            now=ch[now][1];
        }
    }
}
void work()
{
    int l,r;
    root=(n+3)>>1;
    build(1,n+2,root);
    fa[root]=0;
    while(m--)
    {
        l=read<int>();r=read<int>();
        l=find(l);r=find(r+2);
        splay(l,root);splay(r,ch[l][1]);
        rev[ch[r][0]]^=1;
    }
}
void out(int x)
{
    if(rev[x])rever(x);
    if(ch[x][0])out(ch[x][0]);
    if(x>1&&x<n+2)printf("%d ",x-1);
    if(ch[x][1])out(ch[x][1]);
}
int main()
{
    file();
    input();
    work();
    out(root);
    return 0;
}

另外推荐一篇写得好的博客

时间： 2024-10-09 17:26:54

浅谈splay（双旋）的相关文章

浅谈splay（点的操作）

一.基本概念 splay本质:二叉查找树 特点:结点x的左子树权值都小于x的权值,右子树权值都大于x的权值 维护信息: 整棵树:root 当前根节点  sz书上所有结点编号 结点:f[] 父节点编号    ch[][2] 孩子结点编号,0左1右 siz[] 以结点为根的子树大小(包括自己)   cnt[]自己出现的次数 key[] 结点权值 二.基本操作 插入insert.删除del.查询x的排名findpos.查询排名为x的数findx.查找前驱pre.查找后继nex 核心操作:伸展操作spl

[转]浅谈ACM ICPC的题目风格和近几年题目的发展

斯坦福大学 王颖 ACM ICPC的比赛形式一般是五个小时八个题目,综合考察选手的数学能力.算法能力.coding能力和debug能力,还有团队配合能力.数学方面主要强调组合数学.图论和数论这三个方面的能力:而算法的覆盖范围很广,涉及了大部分经典的算法,和少量较前沿的算法.由于每道题目都需要通过所有的测试数据才能得分,并且需要精确解,这限制了Approximation algorithm在一些NP-hard的题目中的运用,从而使得搜索和剪枝策略对于NP-hard的题目非常重要. Final的题目

.net中对象序列化技术浅谈

.net中对象序列化技术浅谈 2009-03-11 阅读2756评论2 序列化是将对象状态转换为可保持或传输的格式的过程.与序列化相对的是反序列化,它将流转换为对象.这两个过程结合起来,可以轻松地存储和传输数 据.例如,可以序列化一个对象,然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象.反之,反序列化根据流重新构造对象.此外还可以将对象序列化后保存到本地,再次运行的时候可以从本地文件 中“恢复”对象到序列化之前的状态.在.net中有提供了几种序列化的方式:二进制序列化

浅谈——页面静态化

现在互联网发展越来越迅速,对网站的性能要求越来越高,也就是如何应对高并发量.像12306需要应付上亿人同时来抢票,淘宝双十一--所以,如何提高网站的性能,是做网站都需要考虑的. 首先网站性能优化的方面有很多:1,使用缓存,最传统的一级二级缓存:2,将服务和数据库分开,使用不同的服务器,分工更加明确,效率更加高:3,分布式,提供多台服务器,利用反向代理服务器nginx进行反向代理,将请求分散开来:4,数据库的读写分离,不同的数据库,将读操作和写操作分开,并实时同步即可:5,分布式缓存,使用memc

单页应用SEO浅谈

单页应用SEO浅谈 前言 单页应用(Single Page Application)越来越受web开发者欢迎,单页应用的体验可以模拟原生应用,一次开发,多端兼容.单页应用并不是一个全新发明的技术,而是随着互联网的发展,满足用户体验的一种综合技术. SEO 一直以来,搜索引擎优化(SEO)是开发者容易忽略的部分.SEO是针对搜索(Google.百度.雅虎搜索等)在技术细节上的优化,例如语义.搜索关键词与内容相关性.收录量.搜索排名等.SEO也是同行.市场竞争常用的的营销手段.Google.百度的搜

浅谈html标签

浅谈html各常用标签用法 标题标签:<h1>-<h6>来表示,使标题字体变粗. <br />换行标记 <hr />水平分隔符 &nbsp空格符 &copy版权符 <a href>a标签超链接 href可接链接地址 <p>段落标签<blockquote>引用标签及可用做缩进 <table>表格中的<ul>无序列表<ol>有序列表<dl>自定义列表<row

浅谈二维中的树状数组与线段树

一般来说,树状数组可以实现的东西线段树均可胜任,实际应用中也是如此.但是在二维中,线段树的操作变得太过复杂,更新子矩阵时第一维的lazy标记更是麻烦到不行. 但是树状数组在某些询问中又无法胜任,如最值等不符合区间减法的询问.此时就需要根据线段树与树状数组的优缺点来选择了. 做一下基本操作的对比,如下图. 因为线段树为自上向下更新,从而可以使用lazy标记使得矩阵的更新变的高校起来,几个不足就是代码长,代码长和代码长. 对于将将矩阵内元素变为某个值,因为树状数组自下向上更新,且要满足区间加法等限制

[nRF51822] 14、浅谈蓝牙低功耗(BLE)的几种常见的应用场景及架构（科普类干货）

蓝牙在短距离无线通信领域占据举足轻重的地位—— 从手机.平板.PC到车载设备, 到耳机.游戏手柄.音响.电视, 再到手环.电子秤.智能医疗器械(血糖仪.数字血压计.血气计.数字脉搏/心率监视器.数字体温计.耳温枪.皮肤水分计等), 再到智能家居等领域均占有一席之地. 而蓝牙低功耗(BLE)是在蓝牙4.0协议上修改以适用低功耗应用场景的一种蓝牙协议. 随着上一股智能消费类电子大潮的到来,BLE的各种应用也像雨后春笋般在市场上铺开. 如果想 紧跟蓝牙协议的最新动态 ,可以在https://www.b

浅谈C++容器动态内存管理的优化

在信息学竞赛中,C++的容器的用途非常广泛,但经常因常数过大而超时.怎样才能提高它们的效率呢? 我们知道,容器是存储同一类对象的对象,既然"对象"我们无法改变,那么我们只能从"存储"入手,不难想到,不同容器在实现上的根本区别是它们对应着不同的内存组织方式,内存管理无疑是这种实现的核心,所以优化内存管理是加快容器效率的最好途径之一. 一.内存分配器简介 怎样才能优化内存管理呢?很简单,C++为我们提供了这样的接口,我们可以通过自定义容器模板中的最后一个allocato