伸展树-入门

最新推荐文章于 2021-05-31 10:36:58 发布
最新推荐文章于 2021-05-31 10:36:58 发布
阅读量408 收藏 1
点赞数
分类专栏： 伸展树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013113958/article/details/49358559
版权
参考博客

博客链接

网上资料不少，留下自己AC代码方便以后回看，用的spt模板是博客里的

1、营业额统计

题目链接
题意：

求最小的营业额波动总和
最小的营业额波动=min(|x-y|)，y是之前某天营业额

解法：

插入某个数，找前序以及后序即可

代码：

#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <stdlib.h>
#include <map>
#include <vector>
#define rep(i,n) for(i=0;i<n;i++)
#define cle(x) memset(x,0,sizeof(x))

#define ll long long
#define keyTree (ch[ ch[root][1] ][0])
const int maxn=100000+5;
using namespace std;
struct SplayTree{
     int ch[maxn][2];
     int pre[maxn];
     int root,top1;
     inline void Rotate(int x,int f)
     {
          //f=1 右旋 f=0 左旋
          int y=pre[x];
          ch[y][!f]=ch[x][f];
          pre[ ch[x][f] ]=y;
          pre[x]=pre[y];
          if(pre[x])ch[ pre[y] ][ ch[pre[y]][1]==y]=x;
          ch[x][f]=y;
          pre[y]=x;
     }
     inline void Splay(int x,int goal) {
          while(pre[x] != goal) {
               if(pre[pre[x]] == goal) {
                    Rotate(x , ch[pre[x]][0] == x);
               } else {
                    int y = pre[x] , z = pre[y];
                    int f = (ch[z][0] == y);
                    if(ch[y][f] == x) {
                         Rotate(x , !f) , Rotate(x , f);
                    } else {
                         Rotate(y , f) , Rotate(x , f);
                    }
               }
          }
          if(goal == 0) root = x;
     }

     inline void NewNode(int &x,int c)
     {
          x=++top1;
          ch[x][0]=ch[x][1]=pre[x]=0;
          val[x]=c;
     }
     inline void Insert(int k)
     {
         int r=root;
         if(r==0)
         {
             ch[0][0]=ch[0][1]=pre[0]=0;
             NewNode(root,k);
             return;
         }
         while(ch[r][val[r]<k])
         {
             r=ch[r][val[r]<k];
         }
         NewNode(ch[r][val[r]<k],k);
         pre[ch[r][val[r]<k]]=r;
         Splay(ch[r][val[r]<k],0);
     }
     inline int Getpre(int r)
     {
         while(ch[r][1])
             r=ch[r][1];
         return val[r];
     }
     inline int Getflo(int r)
     {
         while(ch[r][0])
             r=ch[r][0];
         return val[r];
     }
     inline void Work(int n)
     {
         root=top1=0;
         ll ans=0;
         for(int i=1;i<=n;i++)
         {
             int k;
             if(scanf("%d",&k)==EOF)k=0;
             Insert(k);
             if(i==1)ans+=k;
             else
             {
                 int left=ch[root][0];
                 int right=ch[root][1];
                 int temp=0x3fffffff;
                 if(left){
                     temp=min(temp,k-Getpre(left));
                 }
                 if(right){
                     temp=min(temp,Getflo(right)-k);
                 }
                 ans+=(ll)temp;
             }
         }
         printf("%I64d\n",ans);
     }
     int val[maxn];
}spt;
int main()
{
#ifndef ONLINE_JUDGE
     freopen("in.txt","r",stdin);
     //freopen("out.txt","w",stdout);
#endif
    int n;
    while(~scanf("%d",&n))
    {
        spt.Work(n);
    }
    return 0;
}

2、Double Queue （poj 3481）

题目链接
题意：

1：添加优先级为p的k号机器
2：去掉队列里优先级最高的机器
3：去掉队列里优先级最低的机器

解法：

2：min=while(ch[root][0])，splay(min,0)，并删掉即可
3： 类似，伸展后无右子树

代码：

#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <stdlib.h>
#include <map>
#include <vector>
#define rep(i,n) for(i=0;i<n;i++)
#define cle(x) memset(x,0,sizeof(x))

#define ll long long
const int maxn=1000000+5;
using namespace std;
#define keyTree (ch[ ch[root][1] ][0])
struct SplayTree{
     int ch[maxn][2];
     int pre[maxn];
     int root,top1;
     inline void Rotate(int x,int f)
     {
          //f=1 右旋 f=0 左旋
          int y=pre[x];
          ch[y][!f]=ch[x][f];
          pre[ ch[x][f] ]=y;
          pre[x]=pre[y];
          if(pre[x])ch[ pre[y] ][ ch[pre[y]][1]==y]=x;
          ch[x][f]=y;
          pre[y]=x;
     }
     inline void Splay(int x,int goal) {
          while(pre[x] != goal) {
               if(pre[pre[x]] == goal) {
                    Rotate(x , ch[pre[x]][0] == x);
               } else {
                    int y = pre[x] , z = pre[y];
                    int f = (ch[z][0] == y);
                    if(ch[y][f] == x) {
                         Rotate(x , !f) , Rotate(x , f);
                    } else {
                         Rotate(y , f) , Rotate(x , f);
                    }
               }
          }
          if(goal == 0) root = x;
     }
     inline void NewNode(int &x,int c,int p)
     {
          x=++top1;
          ch[x][0]=ch[x][1]=pre[x]=0;
          val[x]=c;
          ip[x]=p;
     }
     inline void Insert(int k,int p)
     {
         int r=root;
         if(r==0)
         {
             ch[0][0]=ch[0][1]=pre[0]=ip[0]=0;
             NewNode(root,k,p);
             return;
         }
         while(ch[r][val[r]<k])
         {
             r=ch[r][val[r]<k];
         }
         NewNode(ch[r][val[r]<k],k,p);
         pre[ch[r][val[r]<k]]=r;
         Splay(ch[r][val[r]<k],0);
     }
     inline int Getmin(int r)
     {
         while(ch[r][0])r=ch[r][0];
         Splay(r,0);
         return ip[r];
     }
     inline int Getmax(int r)
     {
         while(ch[r][1])r=ch[r][1];
         Splay(r,0);
         return ip[r];
     }
     inline void Work()
     {
         root=top1=0;
         int op;
         while(~scanf("%d",&op)){
             int k,p;
             if(op==1){
                 scanf("%d%d",&k,&p);
                 Insert(p,k);
             }
             else if(op==3)
             {
                 int temp=ip[root];
                 int left=ch[root][0];
                 if(left)
                     temp=Getmin(left);

                 int right=ch[root][1];
                 pre[right]=0;
                 root=right;

                 printf("%d\n",temp);
             }
             else if(op==2)
             {
                 int temp=ip[root];
                 int right=ch[root][1];
                 if(right)
                     temp=Getmax(right);

                 int left=ch[root][0];
                 pre[left]=0;
                 root=left;

                 printf("%d\n",temp);
             }
             else{
                 break;
             }
            // debug();
         }
     }
     int val[maxn];
     int ip[maxn];
}spt;
int main()
{
#ifndef ONLINE_JUDGE
     freopen("in.txt","r",stdin);
     //freopen("out.txt","w",stdout);
#endif
    spt.Work();
    return 0;
}

最后献上 poj 3468段更新 by notonlysuccess

#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <stdlib.h>
#include <map>
#include <vector>
#define rep(i,n) for(i=0;i<n;i++)
#define cle(x) memset(x,0,sizeof(x))

#define ll long long
#define keyTree (ch[ ch[root][1] ][0])
const int maxn=200000+5;
using namespace std;
struct SplayTree{
    int sz[maxn];
    int ch[maxn][2];
    int pre[maxn];
    int root,top1,top2;
    int ss[maxn],que[maxn];

    inline void Rotate(int x,int f)
    {
        //f=1 右旋 f=0 左旋
        int y=pre[x];
        push_down(y);
        push_down(x);
        ch[y][!f]=ch[x][f];
        pre[ ch[x][f] ]=y;
        pre[x]=pre[y];
        if(pre[x])ch[ pre[y] ][ ch[pre[y]][1]==y]=x;
        ch[x][f]=y;
        pre[y]=x;
        push_up(y);
    }
    inline void Splay(int x,int goal) {
        push_down(x);
        while(pre[x] != goal) {
            if(pre[pre[x]] == goal) {
                Rotate(x , ch[pre[x]][0] == x);
            } else {
                int y = pre[x] , z = pre[y];
                int f = (ch[z][0] == y);
                if(ch[y][f] == x) {
                    Rotate(x , !f) , Rotate(x , f);
                } else {
                    Rotate(y , f) , Rotate(x , f);
                }
            }
        }
        push_up(x);
        if(goal == 0) root = x;
    }
    inline void RotateTo(int k,int goal) {//把第k位的数转到goal下边
        int x = root;
        push_down(x);
        while(sz[ ch[x][0] ] != k) {
            if(k < sz[ ch[x][0] ]) {
                x = ch[x][0];
            } else {
                k -= (sz[ ch[x][0] ] + 1);
                x = ch[x][1];
            }
            push_down(x);
        }
        Splay(x,goal);
    }
    inline void NewNode(int &x,int c)
    {
        x=++top1;
        ch[x][0]=ch[x][1]=pre[x]=0;
        sz[x]=1;
        val[x]=sum[x]=c;
        add[x]=0;
    }
    inline void push_down(int x)
    {
        if(add[x])
        {
            val[x]+=add[x];
            int left=ch[x][0];
            int right=ch[x][1];
            add[left]+=add[x],add[right]+=add[x];
            sum[left]+=(ll)sz[left]*add[x];
            sum[right]+=(ll)sz[right]*add[x];
            add[x]=0;
        }
    }
    inline void push_up(int x)
    {
        int left=ch[x][0];
        int right=ch[x][1];
        sz[x]=1+sz[left]+sz[right];
        sum[x]=add[x]+val[x]+sum[left]+sum[right];
    }
    inline void makeTree(int &x,int l,int r,int f)
    {
        if(l>r)
            return;
        int mid=(l+r)>>1;
        NewNode(x,num[mid]);
        makeTree(ch[x][0],l,mid-1,x);//左子树
        makeTree(ch[x][1],mid+1,r,x);
        pre[x]=f;
        push_up(x);
    }
    inline void init(int n)
    {
        ch[0][0]=ch[0][1]=pre[0]=sz[0]=0;
        add[0]=sum[0]=0;
        root=top1=0;
        NewNode(root,-1);
        NewNode(ch[root][1],-1);
        pre[top1]=root;
        sz[root]=2;
        for(int i=0;i<n;i++)
            scanf("%d",&num[i]);
        makeTree(keyTree,0,n-1,ch[root][1]);
        push_up(ch[root][1]);
        push_up(root);
    }
    inline void update()
    {
        int l,r,c;
        scanf("%d%d%d",&l,&r,&c);
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        add[keyTree]+=c;
        sum[keyTree]+=(ll)c*sz[keyTree];
    }
    inline void query()
    {
        int l,r;
        scanf("%d%d",&l,&r);
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        printf("%I64d\n",sum[keyTree]);
    }
    int num[maxn];
    int val[maxn];
    int add[maxn];
    ll sum[maxn];
}spt;
int main()
{
#ifndef ONLINE_JUDGE
     freopen("in.txt","r",stdin);
     //freopen("out.txt","w",stdout);
#endif
    int n,m;
    scanf("%d%d",&n,&m);
    spt.init(n);
    while(m--)
    {
        char op[10];
        scanf("%s",&op);
        if(op[0]=='Q')
            spt.query();
        else
            spt.update();
    }
    return 0;
}

未完，待续

caoyu01
关注
专栏目录
CarSim仿真快速入门(二十一)-CarSim: 车轮箭头动画和其他指示动画
小明师兄的博客
02-24 2275
CarSim2022中的动画是：车轮箭头和其他指标界面用于定义一组轮胎力或其他感兴趣的变量的视觉动画指标，这些指标在仿真车辆的每个车轮、轮胎或车轴上重复出现。所有VehicleSim（VS）产品都包括VS Visualizer，这是一个用于查看虚拟摄像机的动画的程序，它在一个仿真的三维世界中运行。典型的仿真三维世界包括固定物体，如道路、树木和天空，以及移动物体，如仿真车辆的车身和车轮。除了这些明显的物体外，动画还可以通过根据感兴趣的变量调整三维物体的大小或可见度属性来实现其他类型的信息的可视化。
LCT入门（动态树）（点权）（边权）
qq_2992427261
09-23 1913
LCT的用途： 1，在线链接link&cut（连接边，删除边） 2，查询连通性 3，维护链上信息 4，换根 5，维护子树信息。 等等： 基础知识： 1.伸展树（Splay Tree） ：支持链上求和，求最值，修改，等等操作， 2LCT（link cut tree）：是一棵树，长这样： 这上面有一些粗一点的边，我们把它称为重边；还有一些细一点的，我们把它称为轻边。 基本函数功能介绍： ac...
AVL树与伸展树入门
java_c_android的博客
01-18 1216
基础 二叉查找树         对树中的第一个节点X，它的左子树中所有项的值小于X中的项，而右子树中的项都大于X中的项。         二叉查找树的平均深度是O(log N)，因此二叉查找树的操作可以采用递归形式——因为递归不了几次。 增删改查         查找类似于二分法。比根节点大，则找右子树，否则找左子树。         修改也类似于查找，只不过在找到某个元素后对其进行
伸展树（splay）入门学习（一） （洛谷 P3369 【模板】普通平衡树）
BORUSSIA DORTMUND
08-08 415
题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 xx 数 删除 xx 数(若有多个相同的数，因只删除一个) 查询 xx 数的排名(排名定义为比当前数小的数的个数 +1 。若有多个相同的数，因输出最小的排名) 查询排名为 xx 的数 求 xx 的前驱(前驱定义为小于 xx ，且最大的数) 求 xx 的后继(后继定义为大于 xx ，且最小的数...
详细解说数组版伸展树splay及模板
在AC与WA间徘徊
06-08 522
一直不敢写splay,感觉好麻烦，但是今日强迫自己看了bilibili上【算法讲堂】【电子科技大学】【ACM】Splay入门视频，感觉收获很大，比较详细的介绍了好打又好理解的splay，在这里加上注释和自己的理解，结合《史上最详尽的平衡树(splay)讲解与模板》文章的理解，写了如下板子。 此程序是【bzoj3224】普通平衡树的已AC的标程。 //#include&lt;bits/stdc+...
[Splay伸展树]splay树入门级教程
SKY的C
02-28 1万+
本弱鸟对于SPLAY树的一些理解。。。
Splay入门解析【保证让你看不懂（滑稽）】
热门推荐
小蒟蒻yyb的博客
08-26 2万+
BST真是神奇的东西。。。 而且种类好多呀。。。 我这个蒟蒻只学会了splay orzCJ老爷，各种树都会 好好好，不说了，直接说splay。不知道splay是啥，，你也要知道平衡树是啥。。。 平衡树是一个神奇的数据结构， 对于任意一个节点，左儿子的值比它小，右儿子的值比它大 并且任意一棵子树单独拎出来也是一棵平衡树 就像这样。。。。 各位大佬请原谅我丑陋无比的图上面这个丑陋的东西
面试官问我：什么是“伸展树”？
weixin_56537764的博客
05-31 1029
学过数据结构的小伙伴，一定都知道二叉查找树，也叫二叉排序树，英文缩写是BST。 为了维持二叉查找树的高效率查找，就需要对二叉查找树进行平衡调整。在数据结构当中大名鼎鼎的红黑树、AVL，就是典型的自平衡二叉查找树。 今天，我们来介绍一种更有意思的自平衡二叉树：伸展树。它的英文名字是Splay Tree。 Part 1为什么要伸展 我们来回顾一下，二叉搜索树满足：左子结点 < 当前结点 < 右子结点 为什么要有平衡树呢？因为当二叉搜索树如下图“瘸腿”时，搜索左侧的结点，原来的速度...
树结构入门：二叉树的定义与遍历
## 1.1 什么是树结构 树（Tree）是一种抽象数据类型或数据结构，模拟具有树状结构特点的数据组织模型。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。它具有以下特点： - 每个节点有零个或多个子节点； -...
伸展树（Splay tree）学习小结
java开发指南博客 【转载】
07-31 233
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 总结一下最近学习的Splay tree。万事开头难啊，像这种神一样的数据结构，刚学是很痛苦的，建议之前要把平衡树，SBT之类的数据结构先学学。 资料都是网上乱翻的，前一两道题，代码主要追随别人，后面慢慢的调整，成为自己的东西。 Splay tre...
Java数据结构与算法解析(八)——伸展树
一个码农的博客
09-22 1万+
伸展树简介伸展树(Splay Tree)是特殊的二叉查找树。 它的特殊是指，它除了本身是棵二叉查找树之外，它还具备一个特点: 当某个节点被访问时，伸展树会通过旋转使该节点成为树根。这样做的好处是，下次要访问该节点时，能够迅速的访问到该节点。特性1.和普通的二叉查找树相比，具有任何情况下、任何操作的平摊O(log2n)的复杂度，时间性能上更好 2.和一般的平衡二叉树比如 红黑树、AVL树相比，维护
HNOI2002营业额统计 (伸展树---模板题)
u012432475的专栏
05-30 442
#include #include #include #include #include #include #include //HNOI2002 (伸展树---模板题) #define N 100010 #define inf 1<<30 using namespace std; int pre[N], key[N], ch[N][2], root,
数据结构与算法分析之伸展树(splaytree)
mu0206mu的专栏
04-15 6588
1.伸展树，它保证从空树开始任意连续M次对树的操作最多花费O(MlogN)的时间。 2.伸展树的基本思想是，当一个节点a被访问后，通过一系列的AVL树的旋转将a移动到根节点上，这样下次访问时会被快速击中 只需要O(1)的时间。通常一个节点被访问时，它就很可能不久再次被访问。 3.构造伸展树的一个简单方法是从下向上进行单旋转，也就是将访问路径上的每个节点和他们的父节点都实施旋转
伸展树详解及实现(C语言)
Coding365
07-27 2730
1.什么是伸展树 简单的说，伸展树是一棵二叉查找树，对每个节点的访问，都要将该节点通过旋转操作，把它翻转到根处。然后进行操作。下图是访问关键字1的过程（自底向上翻转）。可以看到伸展的效果可以让树的深度变小了，这是伸展树的好处所在。另外，当执行其他操作，如插入和删除，也要先进行类似的伸展。 2.自顶向下伸展树 前面简单地说明自底向上的伸展方式，下面要详细介绍
伸展树
林贻民的博客
07-19 1595
概念伸展树是一种二叉查找树,具有二叉查找树的性质.而与二叉查找树相比,伸展树具有的特点是:当某个节点被访问时，伸展树会通过旋转使该节点成为树根。伸展树操作的时间复杂度较低的原因是:把访问频率高的结点放在根节点附近伸展树的旋转算法伸展树的重点在与旋转算法,有三种旋转类型: zig zig-zig zig-zag 设有结点x,p是x的父母结点,g是p的父母结点zig:当p是根节点,旋转类型为zigzig
【高创新】基于鲸鱼优化算法WOA-Transformer-LSTM实现故障识别Matlab实现.rar
09-18
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
《冯唐成事心法》学习笔记01：逆境来，了怎么办？
最新发布
09-18
《冯唐成事心法》学习笔记01：逆境来，了怎么办？
c语言课程设计-职工资源管理系统.7z
09-18
c语言课程设计-职工资源管理系统.7z
算法艺术指南：入门到进阶
数据结构部分，除了常见的链表、树、堆等，还引入了伸展树、Treap、左偏树、二项堆、Fibonacci堆等高级数据结构，以及后缀数组和线段树等高效的数据处理工具。在数论中，指数和原根、快速分解因数的算法是解决数学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值