【模板】Splay

于 2018-02-27 18:40:09 发布
阅读量303 收藏
点赞数 1
分类专栏： 数据结构 平衡树 splay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/codesf/article/details/79392004
版权
数据结构 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
平衡树
1 篇文章 0 订阅
订阅专栏
splay
1 篇文章 0 订阅
订阅专栏

题目链接：
洛谷 P3369 【模板】普通平衡树（Treap/SBT）
BZOJ 3224: Tyvj 1728 普通平衡树

第一次尝试

第一次splay板子是大佬教给我的，全部用指针完成了splay的基本操作。当时的我码力还是不足，调试了半天极其低级的错误，当时的我还把他们记载在下面：

  • [attempt 1] CE 由于构造函数未在结构体里声明
struct node
{
    int val,siz,cnt;
    node *son[2],*fa;
    node(const int &k);     //<-this line.
    int dir(){return fa->son[1]==this;}
    void upd(){siz=son[0]->siz+son[1]->siz+cnt;}
}*nil=new node(0),*RT,*flag;
node::node(const int &k)
{
    val=k,siz=cnt=1,son[0]=son[1]=fa=nil;
}
  • [attempt 2] WA rotate函数错误
void rotate(node *rt,int d)
{
    node *t=rt->son[d^1];
    rt->son[d^1]=t->son[d];
    if(rt->son[d^1]!=nil)rt->son[d^1]->fa=rt;
    t->son[d]=rt;    //<-this line.
    if(rt->fa!=nil)rt->fa->son[rt->dir()]=t;
    t->fa=rt->fa;rt->fa=t;
    rt->upd();t->upd();
    return;
}
  • [attempt 3] WA delete函数错误
void del(int x)
{
    node *l=lower(RT,x),*r=upper(RT,x);
    if(l==nil&&r==nil)
    {
        if(RT->cnt==1)RT=nil;
        else RT->cnt--,RT->siz--;
        return;
    }
    if(l==nil&&r!=nil)
    {
        splay(r,nil);
        if(RT->son[0]->cnt==1)RT->son[0]=nil;
        else RT->son[0]->cnt--,RT->son[0]->siz--;
        RT->upd();
        return;
    }
    if(r==nil)
    {
        splay(l,nil);
        if(RT->son[1]->cnt==1)RT->son[1]=nil;
        else RT->son[1]->cnt--,RT->son[1]->siz--;
        RT->upd();
        return;
    }
    splay(l,nil);
    splay(r,RT);
    node *obj=RT->son[1]->son[0];
    if(obj->cnt==1)RT->son[1]->son[0]=nil;
    else obj->cnt--,obj->siz--;
    RT->son[1]->upd();
    RT->upd();
    return;
}

这里我调试了很久，比如虚拟节点不能update更新子树大小，再比如删除时只更新了临时变量，没有更改其父亲的儿子指针等等。

第二次尝试

这一次的我经历了一年多的沉淀然而还是那么菜，选择了用数组完成splay这个数据结构。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
inline int read(){
  int x=0,y=1;char c=getchar();
  while(!isdigit(c)){if(c=='-')y=-y;c=getchar();}
  while(isdigit(c)){x=x*10+c-'0';c=getchar();}
  return x*y;
}

const int INF = 100000000;
const int MAXN = 100010;
int son[MAXN][2],fa[MAXN];
int siz[MAXN],rev[MAXN],cnt[MAXN],key[MAXN];
int tot,root;

int getd(int x){return son[fa[x]][1] == x;}

int push_up(int x){
  siz[x] = siz[son[x][0]] + siz[son[x][1]] + cnt[x];
  return 0;
}
void push_down(int x){
  if(rev[x]){
    rev[x]^=1,rev[son[x][0]]^=1,rev[son[x][1]]^=1;
    swap(son[x][0],son[x][1]);
  }
}

void rotate(int x){
  int fat=fa[x],gra=fa[fat],dir=getd(x),fad=getd(fat);
  son[fat][dir]=son[x][dir^1];
  fa[son[x][dir^1]]=fat;
  son[x][dir^1]=fat;
  fa[fat]=x;
  if(gra)son[gra][fad]=x;
  fa[x]=gra;
  push_up(fat);
  push_up(x);
}
int splay(int x,int to){
  while(fa[x]!=to){
    if(fa[fa[x]]!=to&&getd(fa[x])==getd(x))rotate(fa[x]);
    rotate(x);
  }
  if(to==0)root=x;
  return 0;
}

void init(){
  key[1]=-INF,key[2]=INF;
  siz[1]=1,siz[2]=2;
  cnt[1]=cnt[2]=1;
  fa[1]=2,son[2][0]=1;
  root=tot=2;
}

int insert(int now,int fat,int dir,int k){
  if(now==0){
    fa[++tot]=fat,son[fat][dir]=tot;
    cnt[tot]=siz[tot]=1;
    key[tot]=k;
    return tot;
  }
  if(key[now]==k){
    siz[now]++;
    cnt[now]++;
    return now;
  }
  if(key[now]>k)return insert(son[now][0],now,0,k)+push_up(now);
  if(key[now]<k)return insert(son[now][1],now,1,k)+push_up(now);
  return 0;
}

int Find(int now,int x){
  if(now==0)return 0;
  if(key[now]==x)return now;
  if(key[now]>x)return Find(son[now][0],x);
  if(key[now]<x)return Find(son[now][1],x);
}

int get_rank(int now,int k){
  if(now==0)return printf("error\n");
  if(key[now]==k)return siz[son[now][0]]+1;
  if(key[now]>k)return get_rank(son[now][0],k);
  if(key[now]<k)return get_rank(son[now][1],k)+siz[now]-siz[son[now][1]];
  return 0;
}

int find_rank(int now,int k){
  if(now==0)return 0;
  const int L=siz[son[now][0]],N=cnt[now],R=siz[son[now][1]];
  if(k<=L)return find_rank(son[now][0],k);
  if(L<k&&k<=L+N){splay(now,0);return key[now];}
  if(k>L+N)return find_rank(son[now][1],k-L-N);
}

inline int max_key(int x,int y){key[0]=-INF;return key[x]>key[y]?x:y;}
int prev(int now,int k){
  if(now==0)return 0;
  if(key[now]>=k)return prev(son[now][0],k);
  return max_key(prev(son[now][1],k),now);
}

inline int min_key(int x,int y){key[0]=INF;return key[x]<key[y]?x:y;}
int next(int now,int k){
  if(now==0)return 0;
  if(key[now]<=k)return next(son[now][1],k);
  return min_key(next(son[now][0],k),now);
}

int Delete(int k){
  splay(prev(root,k),0);
  splay(next(root,k),root);
  int t=son[son[root][1]][0];
  if(cnt[t]>1){cnt[t]--;siz[t]--;}
  else son[son[root][1]][0]=0;
  push_up(son[root][1]);
  push_up(root);
}

int main(){
  init();
  int n=read();
  while(n--){
    int opt=read(),x=read();
    switch(opt){
      case 1:{
        splay(insert(root,0,0,x),0);
        break;
      }
      case 2:{
        Delete(x);
        break;
      }
      case 3:{
        printf("%d\n",get_rank(root,x)-1);
        splay(Find(root,x),0);
        break;
      }
      case 4:{
        printf("%d\n",find_rank(root,x+1));
        break;
      }
      case 5:{
        printf("%d\n",key[prev(root,x)]);
        break;
      }
      case 6:{
        printf("%d\n",key[next(root,x)]);
        break;
      }
    }
    //for(int i=1;find_rank(root,i)!=INF;i++){
    //  printf("%d ",find_rank(root,i));
    //}
    //printf("\n");
  }
}

关于splay的删除，网上的版本不一，但经过我的搜索，最快的应该是下面这种：

splay的最快删除方法（雾

可以说是非常稳了……

妙！真是妙！

代码如下：

#include<bits/stdc++.h>
using namespace std;
struct node
{
    int val,siz,cnt;
    node *son[2],*fa;
    node(const int &k);
    int dir(){return fa->son[1]==this;}
    void upd(){siz=son[0]->siz+son[1]->siz+cnt;}
}*nil=new node(0),*RT,*flag;
node::node(const int &k)
{
    val=k,siz=cnt=1,son[0]=son[1]=fa=nil;
}
void clear()
{
    nil->siz=nil->cnt=0,RT=nil;
    return;
}
void rotate(node *rt,int d)
{
    node *t=rt->son[d^1];
    rt->son[d^1]=t->son[d];
    if(rt->son[d^1]!=nil)rt->son[d^1]->fa=rt;
    t->son[d]=rt;
    if(rt->fa!=nil)rt->fa->son[rt->dir()]=t;
    t->fa=rt->fa;rt->fa=t;
    rt->upd();t->upd();
    return;
}
void splay(node *rt,node *to)
{
    while(rt->fa!=to)
    {
        if(rt->fa->fa!=to&&rt->dir()==rt->fa->dir())
            rotate(rt->fa->fa,rt->dir()^1);
        rotate(rt->fa,rt->dir()^1);
    }
    if(to==nil)RT=rt;
    return;
}
void add(node *&rt,node *fa,int x)
{
    if(rt==nil)
    {
        rt=new node(x);
        rt->fa=fa;
        flag=rt;
        return;
    }
    if(rt->val==x){rt->cnt++;flag=rt;}
    else if(rt->val>x){add(rt->son[0],rt,x);}
    else {add(rt->son[1],rt,x);}
    rt->upd();
    return;
}
void insert(int x)
{
    add(RT,nil,x);
    splay(flag,nil);
    return;
}
node *lower(node *rt,int x)
{
    if(rt==nil)return nil;
    if(rt->val>=x)return lower(rt->son[0],x);
    else{
        node *t=lower(rt->son[1],x);
        return t==nil?rt:t;
    }
}
node *upper(node *rt,int x)
{
    if(rt==nil)return nil;
    if(rt->val<=x)return upper(rt->son[1],x);
    else
    {
        node *t=upper(rt->son[0],x);
        return t==nil?rt:t;
    }
}
void find(node *rt,int x){
    if(rt==nil)return;
    if(rt->val==x){flag=rt;return;}
    if(rt->val>x)find(rt->son[0],x);
    else find(rt->son[1],x);
    return;
}
void del(int x)
{
    node *l=lower(RT,x),*r=upper(RT,x);
    if(l==nil&&r==nil)
    {
        if(RT->cnt==1)RT=nil;
        else RT->cnt--,RT->siz--;
        return;
    }
    if(l==nil&&r!=nil)
    {
        splay(r,nil);
        if(RT->son[0]->cnt==1)RT->son[0]=nil;
        else RT->son[0]->cnt--,RT->son[0]->siz--;
        RT->upd();
        return;
    }
    if(r==nil)
    {
        splay(l,nil);
        if(RT->son[1]->cnt==1)RT->son[1]=nil;
        else RT->son[1]->cnt--,RT->son[1]->siz--;
        RT->upd();
        return;
    }
    splay(l,nil);
    splay(r,RT);
    node *obj=RT->son[1]->son[0];
    if(obj->cnt==1)RT->son[1]->son[0]=nil;
    else obj->cnt--,obj->siz--;
    RT->son[1]->upd();
    RT->upd();
    return;
}
int rand(int x)
{
    node *rt=RT;int res=1;
    while(rt->val!=x)
    {
        if(rt->val>x)rt=rt->son[0];
        else res=res+rt->son[0]->siz+rt->cnt,rt=rt->son[1];
    }
    res+=rt->son[0]->siz;
    return res;
}
int rand(node *rt,int x)
{
    if(rt->son[0]->siz>=x)return rand(rt->son[0],x);
    if(rt->son[0]->siz+rt->cnt>=x)return rt->val;
    return rand(rt->son[1],x-rt->cnt-rt->son[0]->siz);
}
int read()
{
    int x=0,y=1;char c=getchar();
    while(!isdigit(c)){if(c=='-')y=-y;c=getchar();}
    while(isdigit(c))x=x*10+c-'0',c=getchar();
    return x*y;
}
int main()
{
    clear();
    int n=read();
    while(n--)
    {
        int opt=read(),x=read();
        switch(opt)
        {
            case 1:
            {
                insert(x);
                break;
            }
            case 2:
            {
                del(x);
                break;
            }
            case 3:
            {
                printf("%d\n",rand(x));
                break;
            }
            case 4:
            {
                printf("%d\n",rand(RT,x));
                break;
            }
            case 5:
            {
                printf("%d\n",lower(RT,x)->val);
                break;
            }
            case 6:
            {
                printf("%d\n",upper(RT,x)->val);
                break;
            }
        }
    }
    return 0;
}
/*
10
1 1
4 1
1 3
1 4
*/
coldhac
关注
专栏目录
Splay模板 Splay题型大荟萃
snowy_smile的博客
01-21 822
以HDU4453为例，整理了一些Splay的题型 /* 【算法介绍】 Splay叫做伸展树，是一种二叉搜索树，也可以说是一种平衡树结构。 其可以维护节点的左右次序值，也就是说，我们在Splay上做中序遍历的次序输出节点，得到的便是所有节点的左右次序。 【数据结构】 int ch[N][2], fa[N]; //节点的链接关系 int num[N], sz[N]; //节点个数与子树大小 1
splay 模板
ＡＴＯＤ
12-16 610
#include <iostream> #include <cstdio> #include <cstdlib> #include <algorithm> #include <cstring> #include <cmath> using namespace std; #define rt ch[root][1] #define lrt ch[rt][0] #define ls ch[x][0] #
Splay总结、模板
Cold_Chair的博客
05-08 734
我是来吹水总结的，不是来讲解的。
splay维护序列——模板整理
Lynstery's blog
02-21 611
时间复杂度O(log2nlog_2n)#include<cstdio> #include<cstring> #include<algorithm> using namespace std; struct node{ int key,size; node *ch[2]; void maintain(){ size=ch[0]->size+ch[1]->size+1; }
Splay 总结及模板
Guess_Ha的博客
12-02 733
1.Splay、Rotate 操作 ————————（Splay 旋转） 2.GetPre、GetNext 操作 ——————–（获得前驱后继） 3.GetMin、GetMax 操作 ——————– （获得最小值，最大值） 4.PushUp操作 ——————————— （维护区间信息） 5.Insert 操作 ————————————（插入节点，以二叉排序树原则） ........
（新知）数据结构--Splay--模板
yashem66
12-09 534
写了一发splay的模板，在正常的应用中应该是够用了。除了具备splay特有的功能比如区间的分裂与合并，还具有所有treap的功能，同时也可以维护区间的最大值最小值。对于初次学习splay比较有帮助。
模板splay树
a2491411的博客
04-09 94
本来就搞得差不多了，就是insert那个地方一直看不明白，什么root怎么可以这样用，一翻标程，原来它调用的root是son[0][1]这个真的非常迷啊，你什么都不说调用一个root不是很容易让别人造成误解吗，我还纠结了大半节课 好的好的我不应该裱你对不起后来灵光一现想起来我不是问过我校金牌爷这个问题吗，插入好像有两种方法1把比插入点大的第一个数转到根，判断大小balabala这个我不...
Splay终极模板
zz_ylolita
04-04 1750
写了各种Splay，以下这个版本最让我满意：）。。所以叫“终极”。。。风格飘逸，时间短，代码短也没有恶意缩行。融合各神犇之精华。46 437391(5) SpaceQ 1328 KB 136 MS C++ 1557 B 2013-06-19 23:05:14 非常满意。不加读入优化BZOJ46名。一会儿我试试读入优化的效果。加读入优化以后22 437435(6) SpaceQ
Splay伸展树结构体模板
01-06
Splay结构体的模板，含有各种旋转、插入、翻转等操作，注释清晰
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
Splay模板(BZOJ3224)
Flere825的博客
08-01 508
224: Tyvj 1728 普通平衡树 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 8140  Solved: 3431 [Submit][Status][Discuss] Description 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，
各种树模板(splay,线段树,可持久化线段树...)
DKFsSHIPYARD
12-27 805
模板,反正就是模板
stays mad 反PCL宣传库。Anti PCL pro.zip
10-31
stays mad 反PCL宣传库。Anti PCL pro
伊犁师范大学在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
yolo算法-植物数据集-1417张图像带标签adamweeds.zip
最新发布
10-31
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
clickhouse-jdbc驱动jar文件用于建立jdbc链接
10-31
clickhouse-jdbc驱动jar文件用于建立jdbc链接
辽宁何氏医学院在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值