各类平衡树的学习（一）——Splay

最新推荐文章于 2024-05-07 12:24:19 发布
最新推荐文章于 2024-05-07 12:24:19 发布
阅读量413 收藏
点赞数
分类专栏： 算法入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzk_cpp/article/details/87275662
版权

一.一道模板题.
题目：BZOJ3224.
题目大意：在序列上维护一个数据结构支持：
1.插入数 x x x.
2.删除数 x x x（只删一个）.
3.查找 x x x的最小排名.
4.查找排名为 x x x的数.
5.查找 x x x的前驱.
6.查找 x x x的后继.
1 ≤ n ≤ 1 0 5 1\leq n\leq 10^5 1≤n≤105.

虽然在《各类平衡树的学习（零）——二叉搜索树BST》（建议先去看看）中我们用二叉搜索树来做了下这道题，但这种裸题一般都会卡掉一般的二叉搜索树，所以我们现在需要用到平衡树来维护.

平衡树就是利用一些机制，使得每一次的操作效率是 O ( log ⁡ n ) O(\log n) O(logn)或者是均摊 O ( log ⁡ n ) O(\log n) O(logn)的二叉查找树，常见的平衡树有Treap、Splay、Red-Black Tree、替罪羊树、Size-Balanced Tree、AVL、Leafy Tree等.

在上述的常见的平衡树中，Splay和Treap在OI中较为常用，且功能强大，这里我们就来介绍一下Splay实现各类操作.


二.splay维护的信息与建树.

splay树只需要在普通BST的基础上多存一个父亲指针 f a fa fa，而且建树与普通BST一模一样，下面直接给出代码：

struct tree{
  int x,fa,s[2],siz,cnt;
}tr[N+9];
int cn,rot;

void Pushup(int k){tr[k].siz=tr[tr[k].s[0]].siz+tr[tr[k].s[1]].siz+tr[k].cnt;}

int New_node(int x,int fa){
  tr[++cn]=tree();
  tr[cn].x=x;tr[cn].siz=tr[cn].cnt=1;
  tr[cn].fa=fa;if (fa) tr[fa].s[x>tr[fa].x]=cn;
  return cn;
}

void Build(){cn=0;rot=New_node(-INF,0);New_node(INF,1);Pushup(1);}



三.旋转操作Rotate.

旋转是指把两个节点 x x x和 x x x的父亲 y y y的父子关系改变，即让 x x x成为 y y y，且不破坏原树的二叉查找树性质.

这个过程可以用下面的图来表示：
在这里插入图片描述
那么我们来设计这个旋转函数吧！

首先我们考虑它们在旋转前的关系， t r [ x ] . f a = y , t r [ y ] . f a = z tr[x].fa=y,tr[y].fa=z tr[x].fa=y,tr[y].fa=z.深入探究它们的关系，设 k = t r [ y ] . s [ 1 ] = = x k=tr[y].s[1]==x k=tr[y].s[1]==x，即 t r [ y ] . s [ k ] = x tr[y].s[k]=x tr[y].s[k]=x，那么 t r [ x ] . s [ k ] = 1 , t r [ x ] . s [ k    x o r    1 ] = 2 , t r [ y ] . s [ k    x o r    1 ] = 3 tr[x].s[k]=1,tr[x].s[k\,\,xor\,\,1]=2,tr[y].s[k\,\,xor\,\,1]=3 tr[x].s[k]=1,tr[x].s[kxor1]=2,tr[y].s[kxor1]=3.

考虑把它们旋转后的关系，发生改变的只有 t r [ z ] . s [ t r [ z ] . s [ 1 ] = = y ] = x , t r [ y ] . s [ k ] = 2 , t r [ x ] . s [ k    x o r    1 ] = x tr[z].s[tr[z].s[1]==y]=x,tr[y].s[k]=2,tr[x].s[k\,\,xor\,\,1]=x tr[z].s[tr[z].s[1]==y]=x,tr[y].s[k]=2,tr[x].s[kxor1]=x，所以我们可以写出这样的代码：

void Rotate(int x){
  int y=tr[x].fa,z=tr[y].fa,k=tr[y].s[1]==x;
  if (z) tr[z].s[tr[z].s[1]==y]=x;tr[x].fa=z;
  tr[y].s[k]=tr[x].s[k^1];if (tr[x].s[k^1]) tr[tr[x].s[k^1]].fa=y;
  tr[x].s[k^1]=y;tr[y].fa=x;
  Pushup(y);Pushup(x);
}

当然也有一种写法是把Roatate操作分为左旋（ x < y x<y x<y）和右旋（ x > y x>y x>y）来写的，貌似这样效率会更高，但同时代码也会更长.


四.伸展操作Splay.

Splay操作是splay的核心，它的功能是在不改变树的中序遍历的情况下，把某个节点移到目标节点（通常是根或根的某个儿子）儿子的位置.

具体实现很简单，因为目标节点通常为根或根的儿子，所以只需要把 x x x节点不断往上旋转直到 x x x成为了指定节点的儿子.

具体代码如下：

void Splay(int x,int go){
  for (;tr[x].fa^go;Rotate(x));
  if (!go) rot=x;
  Pushup(x);      //一定要Pushup
}

但是这样的Splay有可能会TLE，这是因为没有时间复杂度保证，它可以被这样一种数据卡掉：
在这里插入图片描述
这个时候我们只需要不断查询 1 , 5 , 1 , 5 , 1 , 5 , . . . 1,5,1,5,1,5,... 1,5,1,5,1,5,...就可以让时间复杂度退化成一次查询 O ( n ) O(n) O(n).

那么我们该如何让时间复杂度变得有保证呢？考虑两种情况：
在这里插入图片描述
第一种情况时， x , y x,y x,y和 y , z y,z y,z的父子关系相同，那么我们就先旋转 y y y，再旋转 x x x；而第二种情况时， x , y x,y x,y和 y , z y,z y,z的父子关系不同，就直接两次旋转 x x x即可.

代码如下：

void Splay(int x,int go){
  int y,z;
  while (tr[x].fa^go){
  	y=tr[x].fa;z=tr[y].fa;
  	if (z) tr[y].s[0]==x^tr[z].s[0]==y?Rotate(x):Rotate(y);
  	Rotate(x);
  }
  if (!go) rot=x;
  Pushup(x);      //一定要Pushup
}

然后我们就能保证一次操作时间复杂度为 O ( log ⁡ n ) O(\log n) O(logn)啦！至于证明在最后…


五.一些与BST差别不大的操作.

splay上所有操作的实现可以写成与BST一模一样，但是为了保证平衡，对于我们使用过的所有从根到一个节点 k k k的链都需要 S p l a y ( k , 0 ) Splay(k,0) Splay(k,0)以保证复杂度.

由于查询前驱后继与删除的代码可以通过splay这个操作写的更加简洁，所以这里先奉上其它几个操作的代码：

int Find_val(int x){
  int k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x]);
  Splay(k?k:fa,0);
  return k?k:-1; 
}

int Insert(int x){
  int k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x]);
  k?++tr[k].cnt:k=New_node(x,fa);
  Splay(k,0);
  return k;
}

int Query_rank(int x){
  int res=0,k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x])
    if (x>tr[k].x) res+=tr[k].cnt+tr[tr[k].s[0]].siz;
  if (k) res+=tr[tr[k].s[0]].siz;
  Splay(k?k:fa,0);
  return res;
}

int Find_rank(int p){
  ++p;
  int k=rot;
  while (2333)
    if (p>tr[tr[k].s[0]].siz+tr[k].cnt) p-=tr[tr[k].s[0]].siz+tr[k].cnt,k=tr[k].s[1];
    else if (p<=tr[tr[k].s[0]].siz) k=tr[k].s[0];
      else break;
  Splay(k,0);
  return k;
}



六.简化前驱与后继的代码.

我们发现若直接用写BST的方式写有些长，考虑是否可以利用splay的先天优势来简化代码呢？

考虑一下上一块中 F i n d _ v a l ( x ) Find\_val(x) Find_val(x)的作用，若 x x x存在，很明显 x x x会被提到根，并且 x x x的前驱和后继只需要一个简单的迭代就可以实现了；若 x x x不存在，则被提到根的节点有可能是 x x x的前驱或后继，这个时候我们需要判定一下是前驱还是后继，另外一个也可以通过简单的迭代实现了.

代码如下：

int Lower(int x){
  Find_val(x);
  int k=rot;
  if (tr[k].x<x) return k;
  for (k=tr[k].s[0];tr[k].s[1];k=tr[k].s[1]);
  Splay(k,0);
  return k;
}

int Upper(int x){
  Find_val(x);
  int k=rot;
  if (tr[k].x>x) return k;
  for (k=tr[k].s[1];tr[k].s[0];k=tr[k].s[0]);
  Splay(k,0);
  return k;
}



七.简化删除的代码.

我们发现BST的删除又臭又长，而且调用的链难以处理，所以考虑简化一下代码.

同样的， F i n d _ v a l ( x ) Find\_val(x) Find_val(x)使得键值为 x x x的节点到了根的地方，若我们要移除根，可以找到 x x x的前驱或后继移到根，再把 x x x移到根儿子的位置，然后就可以直接删除了.

代码如下：

void Erase(int x){
  int k=Find_val(x);
  if (k==-1) return;
  --tr[k].cnt;
  if (tr[k].cnt<0) tr[k].cnt=0;
  if (tr[k].cnt) return;
  int nxt=Upper(tr[k].x);
  Splay(k,nxt);
  tr[nxt].s[0]=tr[k].s[0];if (tr[k].s[0]) tr[tr[k].s[0]].fa=nxt;
  Pushup(nxt);
}



八.通过前驱后继写插入删除.

其实插入删除还可以通过前驱后继写得十分简单.

对于插入 x x x，我们可以先把 x x x的前驱节点 l l l和后继节点 r r r找到，然后把 l l l Splay到根， r r r Splay到 l l l下面，然后 r r r的右儿子就可以直接插入 x x x了…

同理，删除 x x x只需要把插入到 r r r的右儿子改成把 r r r的右儿子设成 0 0 0就可以了…

不过这样写的话常数会很大，所以不是很推荐这样写…

代码如下：

int Insert(int x){
  int l=Lower(x),r=Upper(x),k;
  Splay(l,0);Splay(r,l);
  k=tr[r].s[0];
  k?++tr[k].cnt:k=New_node(x,r);
  Splay(k,0);
  return k;
}

void Erase(int x){
  int l=Lower(x),r=Upper(x),k;
  Splay(l,0);Splay(r,l);
  k=tr[r].s[0];
  if (!k) return;
  --tr[k].cnt;
  if (tr[k].cnt<0) tr[k].cnt=0;
  if (tr[k].cnt) Splay(k,0);
  else tr[r].s[0]=0,Splay(r,0);
}



九.完整代码.

普通平衡树代码如下：

//不用前驱后继简化插入删除
#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=100000,INF=(1<<31)-1;

struct tree{
  int x,fa,s[2],siz,cnt;
}tr[N+9];
int cn,rot;

void Pushup(int k){tr[k].siz=tr[tr[k].s[0]].siz+tr[tr[k].s[1]].siz+tr[k].cnt;}

void Rotate(int x){
  int y=tr[x].fa,z=tr[y].fa,k=tr[y].s[1]==x;
  if (z) tr[z].s[tr[z].s[1]==y]=x;tr[x].fa=z;
  tr[y].s[k]=tr[x].s[k^1];if (tr[x].s[k^1]) tr[tr[x].s[k^1]].fa=y;
  tr[x].s[k^1]=y;tr[y].fa=x;
  Pushup(y);Pushup(x);
}

void Splay(int x,int go){
  for (int y,z;tr[x].fa^go;Rotate(x)){
    y=tr[x].fa;z=tr[y].fa;
    if (z^go) tr[z].s[0]==y^tr[y].s[0]==x?Rotate(x):Rotate(y);
  }
  if (!go) rot=x;
  Pushup(x);
}

int New_node(int x,int fa){
  tr[++cn]=tree();
  tr[cn].x=x;tr[cn].siz=tr[cn].cnt=1;
  tr[cn].fa=fa;if (fa) tr[fa].s[x>tr[fa].x]=cn;
  return cn;
}

void Build(){cn=0;rot=New_node(-INF,0);New_node(INF,1);Pushup(1);}

int Find_val(int x){
  int k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x]);
  Splay(k?k:fa,0);
  return k?k:-1; 
}

int Insert(int x){
  int k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x]);
  k?++tr[k].cnt:k=New_node(x,fa);
  Splay(k,0);
  return k;
}

int Query_rank(int x){
  int res=0,k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x])
    if (x>tr[k].x) res+=tr[k].cnt+tr[tr[k].s[0]].siz;
  if (k) res+=tr[tr[k].s[0]].siz;
  Splay(k?k:fa,0);
  return res;
}

int Find_rank(int p){
  ++p;
  int k=rot;
  while (2333)
    if (p>tr[tr[k].s[0]].siz+tr[k].cnt) p-=tr[tr[k].s[0]].siz+tr[k].cnt,k=tr[k].s[1];
    else if (p<=tr[tr[k].s[0]].siz) k=tr[k].s[0];
      else break;
  Splay(k,0);
  return k;
}

int Lower(int x){
  Find_val(x);
  int k=rot;
  if (tr[k].x<x) return k;
  for (k=tr[k].s[0];tr[k].s[1];k=tr[k].s[1]);
  Splay(k,0);
  return k;
}

int Upper(int x){
  Find_val(x);
  int k=rot;
  if (tr[k].x>x) return k;
  for (k=tr[k].s[1];tr[k].s[0];k=tr[k].s[0]);
  Splay(k,0);
  return k;
}

void Erase(int x){
  int k=Find_val(x);
  if (k==-1) return;
  --tr[k].cnt;
  if (tr[k].cnt<0) tr[k].cnt=0;
  if (tr[k].cnt) return;
  int nxt=Upper(tr[k].x);
  Splay(k,nxt);
  tr[nxt].s[0]=tr[k].s[0];if (tr[k].s[0]) tr[tr[k].s[0]].fa=nxt;
  Pushup(nxt);
}

Abigail getans(){
  int opt,x,n;
  scanf("%d",&n);
  Build();
  while (n--){
  	scanf("%d%d",&opt,&x);
  	switch (opt){
  	  case 1:
  	  	Insert(x);
  	  	break;
  	  case 2:
  	    Erase(x);
  	  	break;
  	  case 3:
  	  	printf("%d\n",Query_rank(x));
  	  	break;
  	  case 4:
  	  	printf("%d\n",tr[Find_rank(x)].x);
  	  	break;
  	  case 5:
  	  	printf("%d\n",tr[Lower(x)].x);
  	  	break;
  	  case 6:
  	    printf("%d\n",tr[Upper(x)].x);
  	  	break;
  	}
  }
}

int main(){
  getans();
  return 0;
}

//用前驱后继简化插入删除
#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=100000,INF=(1<<31)-1;

struct tree{
  int x,fa,s[2],siz,cnt;
}tr[N+9];
int cn,rot;

void Pushup(int k){tr[k].siz=tr[tr[k].s[0]].siz+tr[tr[k].s[1]].siz+tr[k].cnt;}

void Rotate(int x){
  int y=tr[x].fa,z=tr[y].fa,k=tr[y].s[1]==x;
  if (z) tr[z].s[tr[z].s[1]==y]=x;tr[x].fa=z;
  tr[y].s[k]=tr[x].s[k^1];if (tr[x].s[k^1]) tr[tr[x].s[k^1]].fa=y;
  tr[x].s[k^1]=y;tr[y].fa=x;
  Pushup(y);Pushup(x);
}

void Splay(int x,int go){
  for (int y,z;tr[x].fa^go;Rotate(x)){
    y=tr[x].fa;z=tr[y].fa;
    if (z^go) tr[z].s[0]==y^tr[y].s[0]==x?Rotate(x):Rotate(y);
  }
  if (!go) rot=x;
  Pushup(x);
}

int New_node(int x,int fa){
  tr[++cn]=tree();
  tr[cn].x=x;tr[cn].siz=tr[cn].cnt=1;
  tr[cn].fa=fa;if (fa) tr[fa].s[x>tr[fa].x]=cn;
  return cn;
}

void Build(){cn=0;rot=New_node(-INF,0);New_node(INF,1);Pushup(1);}

int Find_val(int x){
  int k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x]);
  Splay(k?k:fa,0);
  return k?k:-1; 
}

int Query_rank(int x){
  int res=0,k=rot,fa=0;
  for (;k&&tr[k].x^x;fa=k,k=tr[k].s[x>tr[k].x])
    if (x>tr[k].x) res+=tr[k].cnt+tr[tr[k].s[0]].siz;
  if (k) res+=tr[tr[k].s[0]].siz;
  Splay(k?k:fa,0);
  return res;
}

int Find_rank(int p){
  ++p;
  int k=rot;
  while (2333)
    if (p>tr[tr[k].s[0]].siz+tr[k].cnt) p-=tr[tr[k].s[0]].siz+tr[k].cnt,k=tr[k].s[1];
    else if (p<=tr[tr[k].s[0]].siz) k=tr[k].s[0];
      else break;
  Splay(k,0);
  return k;
}

int Lower(int x){
  Find_val(x);
  int k=rot;
  if (tr[k].x<x) return k;
  for (k=tr[k].s[0];tr[k].s[1];k=tr[k].s[1]);
  Splay(k,0);
  return k;
}

int Upper(int x){
  Find_val(x);
  int k=rot;
  if (tr[k].x>x) return k;
  for (k=tr[k].s[1];tr[k].s[0];k=tr[k].s[0]);
  Splay(k,0);
  return k;
}

int Insert(int x){
  int l=Lower(x),r=Upper(x),k;
  Splay(l,0);Splay(r,l);
  k=tr[r].s[0];
  k?++tr[k].cnt:k=New_node(x,r);
  Splay(k,0);
  return k;
}

void Erase(int x){
  int l=Lower(x),r=Upper(x),k;
  Splay(l,0);Splay(r,l);
  k=tr[r].s[0];
  if (!k) return;
  --tr[k].cnt;
  if (tr[k].cnt<0) tr[k].cnt=0;
  if (tr[k].cnt) Splay(k,0);
  else tr[r].s[0]=0,Splay(r,0);
}

Abigail getans(){
  int opt,x,n;
  scanf("%d",&n);
  Build();
  while (n--){
  	scanf("%d%d",&opt,&x);
  	switch (opt){
  	  case 1:
  	  	Insert(x);
  	  	break;
  	  case 2:
  	    Erase(x);
  	  	break;
  	  case 3:
  	  	printf("%d\n",Query_rank(x));
  	  	break;
  	  case 4:
  	  	printf("%d\n",tr[Find_rank(x)].x);
  	  	break;
  	  case 5:
  	  	printf("%d\n",tr[Lower(x)].x);
  	  	break;
  	  case 6:
  	    printf("%d\n",tr[Upper(x)].x);
  	  	break;
  	}
  }
}

int main(){
  getans();
  return 0;
}



十.时间复杂度分析.

splay的具体如何用严谨的势能法分析我还不会，但是可以写一下主要的思想.

显然造成一棵BST不平衡的节点必然只有一种节点——只有一个儿子的节点.

而splay一次双旋的作用效果是什么？就是破坏掉这种节点.

再来考虑每次构造这种节点必然需要 O ( 1 ) O(1) O(1)个操作，破坏这种节点必然只需要 O ( 1 ) O(1) O(1)次splay也就是 O ( log ⁡ n ) O(\log n) O(logn)的复杂度，而操作次数只有 n n n次，所以复杂度是 O ( n log ⁡ n ) O(n\log n) O(nlogn)的.

hezlik
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡树学习笔记
Recalling_Clouds的博客
01-12 256
平衡树学不会的，这辈子都学不会的 一、前置芝士 平衡树本质上看是一种 BST（二叉排序树） 而 BST 其实是一种非常容易理解的良心数据结构 BST 保证了这颗树的中序遍历是单调上升的 举个例子： BST 支持插入、删除以及查询等多种操作，我们一一来讲述 插入 插入很简单 我们知道二叉排序树有一个性质：对于每一个结点，设它的点权为 valvalval，那么它的左子树中的每一个点权值必定小于 valvalval，它的右子树中的每一个点权值必定大于 valvalval 插入时我们对于当前访问到的点的权值
对六种平衡树的研究与探索【全面】【更新中】
lemonoil的博客
02-10 1万+
对平衡树的研究与探索四川省第七中学（高新校区） 李明洋 对平衡树的研究与探索 摘要 关键字 二叉搜索树 treap splay sbt rbt 替罪羊树 AVL 正文 一引言 二各类平衡树的基本介绍 平衡二叉树 treap 基本介绍 补充 替代rand 可持久化 核心的步骤 旋转 插入删除和选择第k小项 操作及模板 sbt节点大小平衡树 基本介绍 补充 与标准版的比较 插入人字形数据后退化的SBT
各类平衡树的学习（二）——Treap
hzk_cpp的博客
02-28 252
一.一道模板题. 题目：BZOJ3224. 题目大意：在序列上维护一个数据结构支持： 1.插入数xxx. 2.删除数xxx（只删一个）. 3.查找xxx的最小排名. 4.查找排名为xxx的数. 5.查找xxx的前驱. 6.查找xxx的后继. 1≤n≤1051\leq n\leq 10^51≤n≤105. 在各类平衡树的学习（一）——Splay中，我们用splay解决了这个问题，接下来我们将会用另一...
洛谷 P3391：文艺平衡树 ← Splay树模板题
最新发布
hnjzsyjyj的专栏
05-07 948
● Treap 树解决平衡的办法是给每个结点加上一个随机的优先级，实现概率上的平衡。Splay 树直接用旋转调整树的形态，通过旋转改善树的平衡性。计算量小，效果好。 ● Splay 树的旋转主要分为“单旋”和“双旋”。
【算法】数据结构与算法分析学习笔记——各类二叉查找树的吐血整理
jyyyyyy
02-19 908
二叉查找树的吐血整理
伸展树Splay【非指针版】
weixin_30685047的博客
03-28 74
·伸展树有以下基本操作（基于一道强大模板题:codevs维护队列）： a[]读入的数组;id[]表示当前数组中的元素在树中节点的临时标号;fa[]当前节点的父节点的编号;c[][]类似于Trie,就是一个邻接表,存储左右儿子编号;sum[]区间和；size[]当前根节点所在区间的大小;v[]节点权值;mx[]当前区间连续和最大值;rx[]当前区间右端点连续和最大值lx[]当前区间左端...
替罪羊树~讲解
06-26 427
\(Scapegoat\)_\(Tree\) ——(替罪羊树) ——识替罪羊树之算法乃吾生之幸也！ \(First\).引子： 知乎上面有个问题问最优雅的算法是什么，我觉得 暴力即是优雅。 当然这里说的暴力并不是指那种不加以思考的无脑的暴力，而是说用繁琐而技巧性的工作可以实现的事，我用看似简单的思想和方法，也可以达到近似于前者的空间复杂度和时间复杂度，甚至可以更优，而其中也或多或少的...
心灵电脑汤——2016寒假培训总结（NOIP）
diaozhu6431的博客
02-26 126
这个寒假去了河南，见到了许多大犇，我也渴望像他们一样静静地装逼。培训完了感觉，额，其实在这个世界上有很多装逼的方式······ 前两天听了北大的李煜东神犇的课，讲的真TM的好，“这个XXX大家都会吧。”“会个J8！”、“这个XXX其实很水的。”“你若做一只王八。”······WTF！朱全民老先生讲得很有激情，虽然净扯些没用的东西。最后两天，来了个金牌选手王逸松，其实就是个...
STL之set——从“Luogu P2234 [HNOI2002]营业额统计”切入
Mr_Fmnwon的博客
09-20 393
集合是C++STL容器中的重要一员，有着元素唯一等特性，本篇博客将从Luogu相关题目入手，整理相关的知识，归纳总结。一、题目set 容器定义于头文件，并位于 std 命名空间中。和 map、multimap 容器不同，使用 set 容器存储的各个键值对，要求键 key 和值 value 必须相等。显然，第一组数据中各键值对的键和值不相等，而第二组中各键值对的键和值对应相等。对于 set 容器来说，只能存储第 2 组键值对，而无法存储第一组键值对。
繁凡的ACM模板（满注释模板）
热门推荐
繁凡さん的博客
04-13 3万+
ACM模板，不同于其他大佬的是我这个模板是满注释的！哪怕是小白的你考场上都能快速上手算法，每一句都有注释帮你快速理解，方便对模板根据题意的修改
splay平衡树
04-08
splay程序，希望大家可以看一下，适合新手
平衡树Splay代码
08-27
Splay，平衡树的一种，支持部分区间操作。
c++写的平衡树数据结构
03-24
平衡树的主要类型包括AVL树、红黑树、Splay树和Treap等。在这个C++实现中，我们可能看到的是AVL树或者红黑树，因为它们是最常见的平衡树类型，且都支持高效的插入和删除操作。AVL树以其严格的平衡条件（所有节点的...
SML.zip_SML树_人工智能/神经网络/深度学习_平衡树
09-21
SML（一种可能指的是Standard ML编程语言）在这里可能用于实现特定的数据结构——平衡树。平衡树是一种自平衡二叉查找树，它的主要特点是左右子树的高度差不超过一，这确保了树的操作如插入、删除和搜索具有良好的...
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
偏序关系与偏序集相关
hzk_cpp的博客
08-28 6650
一.偏序集的定义. 偏序集：定义一个偏序集是由一个集合SSS与一个二元关系≤\leq≤组成的二元组G={S,≤}G=\{S,\leq\}G={S,≤}，满足： 自反性：对于任意元素x∈Sx\in Sx∈S，有x≤xx\leq xx≤x. 传递性：对于任意元素x,y,z∈Sx,y,z\in Sx,y,z∈S，若x≤y,y≤zx\leq y,y\leq zx≤y,y≤z，则x≤y≤zx\leq y\l...
竞赛图（有向完全图）上哈密顿路径的若干性质（BZOJ4727 [POI2017]Turysta 题解）
hzk_cpp的博客
02-28 4745
一.竞赛图与哈密顿路径的定义. 竞赛图：竞赛图是一张有向无环图G={V,E}G=\{V,E\}G={V,E}，满足有∣E∣=∣V∣(∣V∣−1)|E|=|V|(|V|-1)∣E∣=∣V∣(∣V∣−1)边且两点之间仅有一条边，也就是说两点之间有且仅有一条边. 哈密顿路径：一条经过nnn个点的简单路径，即不能重复经过一个点. 哈密顿回路：一条哈密顿回路相当于一条哈密顿路径的终点与起点也通过一条边连起来...
基本DP模型总结
hzk_cpp的博客
11-11 4713
前言. 这篇文章不贴代码，只是介绍最基本的DP模型，基本都是列出基本的状态和转移方程或者导向另一篇题解. 约定： 1.记[a][a][a]表示判定表达式aaa是否为真，为真则值为111，为假则值为000. 2.记fakfa_{k}fak​表示kkk的父亲节点，sonkson_{k}sonk​表示kkk的子节点集合. 3.记f↔gf\leftrightarrow gf↔g表示状态ggg会对状态fff...
用C++写一个splay平衡树
02-19
我不是很熟悉C语言，但是我可以给你一些关于splay平衡树的基本知识：splay平衡树是一种二叉搜索树，它的特点是能够将最近使用的元素放在树的顶层，以提高查询效率。它的搜索过程和普通二叉搜索树类似，但是它会在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值