SBT

最新推荐文章于 2024-04-25 14:51:14 发布
最新推荐文章于 2024-04-25 14:51:14 发布
阅读量499 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a569329637/article/details/17490165
版权
SBT（Size Balanced Tree）是陈启峰提出的一种平衡二叉树，下面是 他的论文，中文版的论文 在这里。 
SBT树模板
const int maxn = 10000000+10;
struct SBT {
      int l, r, key, s;
      void init(int k) {
            l = r = 0, s = 1, key = k;
      }
}T[maxn];
int next, root, n, m;

void init() {//初始化SBT树的root和next
      next = root = 0;
}
void Right_Rotate(int &t) {//右旋转
      int k = T[t].l;
      T[t].l = T[k].r;
      T[k].r = t;
      T[k].s = T[t].s;
      T[t].s = T[T[t].l].s+T[T[t].r].s+1;
      t = k;
}
void Left_Rotate(int &t) {//左旋转
      int k = T[t].r;
      T[t].r = T[k].l;
      T[k].l = t;
      T[k].s = T[t].s;
      T[t].s = T[T[t].l].s+T[T[t].r].s+1;
      t = k;
}
void Maintain(int &t, bool flag) {//保持SBT树的性质
      if (t==0) return;
      if (!flag) {
            if (T[T[T[t].l].l].s>T[T[t].r].s)
                  Right_Rotate(t);
            else if (T[T[T[t].l].r].s>T[T[t].r].s)
                  Left_Rotate(T[t].l), Right_Rotate(t);
            else return;
      } else {
            if (T[T[T[t].r].r].s>T[T[t].l].s)
                  Left_Rotate(t);
            else if (T[T[T[t].r].l].s>T[T[t].l].s)
                  Right_Rotate(T[t].r), Left_Rotate(t);
            else return;
      }
      Maintain(T[t].l, false);
      Maintain(T[t].r, true);
      Maintain(t, false);
      Maintain(t, true);
}
void Insert(int &t, int key) {
      if (t==0) {//插入结点
            t = ++next;
            T[t].init(key);
      } else {
            T[t].s ++;
            if (key<T[t].key)
                  Insert(T[t].l, key);
            else
                  Insert(T[t].r, key);
      }
      Maintain(t, key>=T[t].key);
}
//删除关键字为key的结点，没有该结点，删除搜索到最后的一个结点
int Delete(int &t, int key) {//删除就是一个覆盖的过程
      T[t].s--;
      if ((T[t].key==key)||(T[t].l==0 && key<T[t].key)||(T[t].r==0 && key>T[t].key)) {
            int tmp = T[t].key;
            if (T[t].l==0 || T[t].r==0)//用左儿子（或右儿子）覆盖该结点
                  t = T[t].l+T[t].r;
            else//(T[t].key==key)时的情况用下面的结点覆盖该结点
                  T[t].key = Delete(T[t].l, T[t].key+1);
            return tmp;//返回该结点原来的值
      } else {
            Delete(key<T[t].key?T[t].l:T[t].r, key);
      }
}
int Find(int t, int key) {//查找并返回关键字为key的结点
      if (t==0)
            return 0;//不存在返回0
      if (T[t].key==key)
            return t;
      else if (key<T[t].key)
            return Find(T[t].l, key);
      else
            return Find(T[t].r, key);
}
//返回key在以t为根的树中的排名，也就是比key小的那颗树的size加一
int Rank(int t, int key) {
      if (t==0)//key小于最小值时有问题
            return 1;
      else if (key==T[t].key)
            return T[T[t].l].s+1;
      else if (key>T[t].key)
            return T[T[t].l].s+1+Rank(T[t].r, key);
      else
            return Rank(T[t].l, key);
}
//返回在第k位置上的结点，取最大值Select(t, T[t].s)，最小值Select(t, 1)
int Select(int t, int k) {
      if (k==T[T[t].l].s+1)
            return T[t].key;
      else if (k>T[T[t].l].s)
            return Select(T[t].r, k-T[T[t].l].s-1);
      else
            return Select(T[t].l, k);
}
int Pred(int t, int key) {//返回比key小的最大的数
      if (t==0)
            return key;
      if (key<=T[t].key)
            return Pred(T[t].l, key);
      else {
            int tmp = Pred(T[t].r, key);
            return tmp==key?T[t].key:tmp;
      }
}
int Succ(int t, int key) {//返回比key大的最小的数
      if (t==0)
            return key;
      if (key>=T[t].key)
            return Succ(T[t].r, key);
      else {
            int tmp = Succ(T[t].l, key);
            return tmp==key?T[t].key:tmp;
      }
}
void Debug(int t) {
      if (t==0)
            return ;
      Debug(T[t].l);
      printf("%d ", T[t].key);
      Debug(T[t].r);
}
NOI2004 郁闷的出纳员 
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 2000000+10;
struct sbt {
      int l, r, s, key;
      void init(int k) {
            l = r = 0, s = 1, key = k;
      }
}T[maxn];
int next, root, n, ans, tmp, Min, d;
char s[11];

void init() {
      next = root = 0;
      tmp = ans = 0;
      T[0].init(0);
      T[0].s = 0;
}
void Right_Rotate(int &t) {
      int k = T[t].l;
      T[t].l = T[k].r;
      T[k].r = t;
      T[k].s = T[t].s;
      T[t].s = T[T[t].l].s+T[T[t].r].s+1;
      t = k;
}
void Left_Rotate(int &t) {
      int k = T[t].r;
      T[t].r = T[k].l;
      T[k].l = t;
      T[k].s = T[t].s;
      T[t].s = T[T[t].l].s+T[T[t].r].s+1;
      t = k;
}
void Maintain(int &t, bool flag) {
      if (!flag) {
            if (T[T[T[t].l].l].s>T[T[t].r].s)
                  Right_Rotate(t);
            else if (T[T[T[t].l].r].s>T[T[t].r].s)
                  Left_Rotate(T[t].l), Right_Rotate(t);
            else return ;
      } else {
            if (T[T[T[t].r].r].s>T[T[t].l].s)
                  Left_Rotate(t);
            else if (T[T[T[t].r].l].s>T[T[t].l].s)
                  Right_Rotate(T[t].r), Left_Rotate(t);
            else return ;
      }
      Maintain(T[t].l, false);
      Maintain(T[t].r, true);
      Maintain(t, false);
      Maintain(t, true);
}
void Insert(int &t, int key) {
      if (t==0) {
            t = ++next;
            T[t].init(key);
      } else {
            T[t].s++;
            if (key<T[t].key)
                  Insert(T[t].l, key);
            else
                  Insert(T[t].r, key);
      }
      Maintain(t, key>=T[t].key);
}
int Delete(int &t, int key) {
      T[t].s--;
      if ((T[t].key==key)||(T[t].l==0 & key<T[t].key)||(T[t].r==0 && key>=T[t].key)) {
            int tmp = T[t].key;
            if (T[t].l==0 || T[t].r==0)
                  t = T[t].l+T[t].r;
            else
                  T[t].key = Delete(T[t].r, key);
            return tmp;
      } else {
            if (key<T[t].key)
                  Delete(T[t].l, key);
            else
                  Delete(T[t].r, key);
      }
}
int Select(int t, int k) {
      if (T[T[t].l].s+1==k) {
            return T[t].key;
      } else if (k<=T[T[t].l].s) {
            return Select(T[t].l, k);
      } else {
            return Select(T[t].r, k-T[T[t].l].s-1);
      }
}
void Debug(int t) {
      if (t==0)
            return ;
      Debug(T[t].l);
      printf("%d ", T[t].key);
      Debug(T[t].r);
}

int main()
{
      init();
      cin >> n >> Min;
      while (n--) {
            scanf("%s%d", s, &d);
            if (s[0]=='I') {
                  if (d>=Min) {
                        Insert(root, d-tmp);
                  }
            } else if (s[0]=='A') {
                  tmp += d;
            } else if (s[0]=='S') {
                  tmp -= d;
                  while (1) {
                        int qian = Select(root, 1);
                        if ((qian+tmp)<Min) {
                              Delete(root, qian);
                              ans ++;
                        } else  break;
                        if (T[root].s==0)
                              break;
                  }
            } else if (s[0]=='F') {
                  if (d>T[root].s) {
                        printf("-1\n");
                  } else {
                        printf("%d\n", Select(root, T[root].s-d+1)+tmp);
                  }
            }
      }
      cout << ans << endl;
      return 0;
}
HNOI2002 营业额统计 
#include <iostream>
#include <cstdio>
using namespace std;

const int maxn = 1000000+10;
struct sbt {
      int l, r, s, key;
      void init(int k) {
            l = r = 0, s = 1, key = k;
      }
}T[maxn];
int next, root, n, data, ans;

void init() {
      next = root = ans = 0;
      T[0].init(0);
      T[0].s = 0;
}
void Left_Rotate(int &t) {
      int k = T[t].r;
      T[t].r = T[k].l;
      T[k].l = t;
      T[k].s = T[t].s;
      T[t].s = T[T[t].l].s+T[T[t].r].s+1;
      t = k;
}
void Right_Rotate(int &t) {
      int k = T[t].l;
      T[t].l = T[k].r;
      T[k].r = t;
      T[k].s = T[t].s;
      T[t].s = T[T[t].l].s+T[T[t].r].s+1;
      t = k;
}
void Maintain(int &t, bool flag) {
      //if (t==0)
      //      return ;
      if (!flag) {
            if (T[T[T[t].l].l].s>T[T[t].r].s)
                  Right_Rotate(t);
            else if (T[T[T[t].l].r].s>T[T[t].r].s)
                  Left_Rotate(T[t].l), Right_Rotate(t);
            else return ;
      } else {
            if (T[T[T[t].r].r].s>T[T[t].l].s)
                  Left_Rotate(t);
            else if (T[T[T[t].r].l].s>T[T[t].l].s)
                  Right_Rotate(T[t].r), Left_Rotate(t);
            else return ;
      }
      Maintain(T[t].l, false);
      Maintain(T[t].r, true);
      Maintain(t, false);
      Maintain(t, true);
}
void Insert(int &t, int key) {
      if (t==0) {
            t = ++next;
            T[t].init(key);
      } else if (key<T[t].key) {
            T[t].s++;
            Insert(T[t].l, key);
      } else {
            T[t].s++;
            Insert(T[t].r, key);
      }
      Maintain(t, key>=T[t].key);
}
int Succ(int t, int key) {
      if (t==0)
            return key;
      if (key>=T[t].key) {
            return Succ(T[t].r, key);
      } else {
            int tmp = Succ(T[t].l, key);
            return tmp==key?T[t].key:tmp;
      }
}
int Pred(int t, int key) {
      if (t==0)
            return key;
      if (key<=T[t].key) {
            return Pred(T[t].l, key);
      } else {
            int tmp = Pred(T[t].r, key);
            return tmp==key?T[t].key:tmp;
      }
}
int Find(int t, int key) {
      if (t==0)
            return 0;
      else if (key==T[t].key) {
            return 1;
      } else if (key<T[t].key) {
            return Find(T[t].l, key);
      } else {
            return Find(T[t].r, key);
      }
}
void Debug(int t) {
      if (t==0)
            return;
      Debug(T[t].l);
      printf("%d ", T[t].key);
      Debug(T[t].r);
}
inline int abs(int x) {
      return x<0?(-x):x;
}
inline int Min(int x, int y) {
      return x>y?y:x;
}

int main()
{
      while (~scanf("%d", &n)) {
            init();
            for (int i=0; i<n; ++i) {
                  if(scanf("%d",&data)==EOF)data=0;
                  if (i==0) {
                        ans += data;
                  } else if (i==1) {
                        ans += abs(data-T[root].key);
                  } else {
                        if (Find(root, data)==0) {
                              int qian = Pred(root, data);
                              int hou = Succ(root, data);
                              if (qian==data) {
                                    ans += abs(data-hou);
                              } else if (hou==data) {
                                    ans += abs(data-qian);
                              } else {
                                    ans += Min(abs(data-qian), abs(data-hou));
                              }
                        }
                  }
                  Insert(root, data);
            }
            cout << ans << endl;
      }
      return 0;
}

CCSU_HelloWorld
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SBT 综述
孟岩
08-16 3493
SBT 综述---迈向 Web3 的重要观念突破作者：Solv 研究组导言5 月初 SBT 论文发表之后，迅速成为整个 Web3 领域最热门的话题之一。我本人在数字资产领域学习实践多年，对于 SBT 一方面感到兴奋，另一方面也多少有些怅然。兴奋是容易理解的，怅然何解呢？主要是因为，在创建去中心化的信誉体系这个问题上，类似 SBT 这样的思路，之前也有人提出来过，甚至有些想法也很精彩。然而，...
sbt-1.9.0.tgz
08-07
SBT，全称为Scala Build Tool，是用于构建和管理Scala及Java项目的强大工具。它以其高效、灵活和可扩展性而受到开发者的广泛欢迎。在本文中，我们将深入探讨SBT的基本概念、功能以及如何使用它来管理项目。 首先，...
【数据结构与算法】Size Balanced Tree（SBT）平衡二叉树
小哲的博客
11-02 1477
尺寸平衡树（SBT）平衡二叉树 原文链接大小平衡树（SBT）平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N]; 关键：存储值，左，右：左右子树，大小：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点X，同时满足下面两个条件 (a)、x.left.size &gt;= max(x.r...
sbt使用教程
a18792721831的博客
02-13 4674
sbt使用教程sbt 配置sbt 单项目构建sbt 多项目构建sbt 配置定义sbt 任务定义sbt 作用域sbt 插件总结 sbt 配置 sbt 使用ivy作为自己的依赖库，类似maven的.m2文件夹，里面存储了sbt的缓存等信息。 sbt本身有一些配置，但是这些配置在官网文档中没有说明，不过我们可以在sbtopts文件中查看相关的配置信息 sbtopts文件在/sbt/conf文件夹下 首先是仓库信息，配置的仓库决定了我们下载依赖的包的速度，我们可以选择国内的镜像，这样下载速度会比较快。 首先在/s
如何安装sbt（sbt在ubuntu上的安装与配置）（有详细安装网站和图解）
最新发布
weixin_66547608的博客
04-25 1970
教你如何安装配置sbt，使用sbt进行一些打包命令，用详细图解和代码，新手小白也可以使用
竞赛最好用的平衡树-Size Balanced Tree（SBT）【建议收藏】
x0919的博客
10-24 2971
大家好。 前段时间我更新过AVL、红黑树以及搜索二叉树的简单讲解。今天我们还是围绕着平衡树的话题，来讲解一个很牛逼的平衡树结构。这种结构是我国的一位大牛：陈启峰。在2006年，他还在读高中阶段，所发明的一种平衡树结构，叫Size Balanced Tree（SBT），根据节点的个数，来调整平衡性。一直到今天，这种平衡树结构，在算法竞赛领域是非常常用的，虽然SBT的时间复杂度跟AVL、红黑树这些平衡树一样，但是SBT是比较好写，比较好改的。所以在算法竞赛时，是最常用的一种算法。陈启峰SBT论文（译） 本期文章
sbt入门
a18792721831的博客
02-10 2147
sbt入门sbt 介绍sbt 下载sbt 安装sbt 入门 -- helloworldsbt 目录结构sbt 命令总结 sbt 介绍 sbt是什么？ sbt到底是什么，在网上找找，似乎找不到一个非常准确，而且大家都认可的定义。 我自己对sbt的理解没有那么复杂，主要是以下这些。 sbt翻译为simple build tool，这是一种较为直观的，而且比较符合sbt官网的一些信息： 在官网的首页上第一条就说明sbt是一个简单的构建工具，所以翻译为simple build tool似乎也没有什么不妥。 不过就
sbt-1.3.8.tar.gz
04-05
【sbt-1.3.8.tar.gz】是一款基于Scala的构建工具，它在Java开发领域，特别是处理Scala项目时，扮演着至关重要的角色。这个压缩包文件包含了sbt（Simple Build Tool）版本1.3.8的所有必要组件，允许开发者高效地构建...
SBT.rar_SBT
09-19
SizeBalanceTree（SBT）是一种新兴的平衡树算法，它在平衡二叉查找树的基础上，进一步优化了树的平衡状态，确保了操作的时间复杂度稳定在O(log n)。本文将深入探讨SBT的基本概念、结构特性以及实现策略。 **一、SBT...
sbt-0.13.15
07-20
**Sbt-0.13.15：Scala构建工具详解** Sbt（Simple Build Tool）是Scala项目的主要构建工具，它以其强大的功能和高效的工作流在开发社区中备受推崇。0.13.15是Sbt的一个版本，虽然现在已经有了更高级的版本，但了解...
sbt 0.13.15安装包
06-15
**SBT 0.13.15 安装与使用详解** SBT（Simple Build Tool）是Scala项目的主要构建工具，它为Scala和Java项目提供了高效、灵活的构建方式。版本0.13.15是SBT的一个重要里程碑，尽管后续版本已经更新到1.x系列，但...
SBT模板(平衡树)
04-02
本模板为 BZOJ3224：文艺平衡树 的源程序 含各种操作，旋转，插入，删除，求前驱，后继，查询值为x的数的排名，查询排名为k的数，求最大值，最小值……
sbt-0.13.8 for windows
10-16
官网找不到此版本，好了很久终于找到了，分享给大家。
sbt-1.2.7windows最新安装包
12-01
sbt-1.2.7windows最新安装包，Scala编译插件
SBT陈启峰（高级数据结构）
05-30
由中山纪念中学陈启峰写的介绍SBT的课件 有其原理及重要部分的代码 是他弄的一个很好很简单的高级数据结构（可与AVL treap splay等媲美）
SBTree的概念以及代码实现
alex1997222的博客
11-03 2292
SBTree与AVL树具有相同的概念,也具有相同的操作类似自平衡,旋转操作和旋转的触发这三方面介绍SBTree SBTree严格遵循下列公式,如有违反,则需要通过相应的转置操作来达到平衡 SIZE[right[t]] &gt;= max(SIZE[left[left[t]]], SIZE[right[left[t]]]); SIZE[left[t]] &gt;= max(SIZE[left[...
sbt学习
金字塔上的蜗牛的专栏
06-02 675
sbt simple build tool sbt是一个现代构建工具。 安装方法： ubuntu and debian-based distributions echo "deb https://dl.bintray.com/sbt/debian /" | sudo tee -a /etc/apt/sources.list.d/sbt.list sudo apt-key adv
SBT树
weixin_34167043的博客
01-08 490
转自：http://jcf94.com/2015/06/19/2015-06-19-sbt/ 总结： 二叉查找树（或称二叉搜索树、二叉排序树）：大的右边、小的左边。问题：不平衡，输入有序情况下从平均性能O(lgn)退化为O(n) 平衡树（平衡二叉查找树）：通过节点的左旋、右旋操作来维护二叉查找树的平衡。如红黑树、AVL树、SBT、Treap、Splay等，它们的区别在于维护平衡的方式不同。 ...
为什么要学习SBT？
齐梦星空
05-12 8062
SBT教程 前言   写这篇教程只针对新手，如果你已经有一定的通过SBT管理项目的经验的时候这篇教程可能已经不太适合你了。因为写的都是一些很基础的入门的东西。 SBT简介   为了文章结构完整，在这里把把能找到的一些sbt简介附上让大家看一下： sbt is a build tool for Scala, Java, and more. It requires Java 1.6...
sbt安装与入门指南
"sbt官网学习文档" `sbt`（Simple Build Tool）是Scala语言的构建工具，它提供了灵活的项目管理和构建过程。sbt利用Scala的特性，允许用户以编程方式定义项目设置和构建逻辑，这使得sbt比传统的基于XML的构建工具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值