splay学习总结

最新推荐文章于 2019-04-24 14:49:00 发布
最新推荐文章于 2019-04-24 14:49:00 发布
阅读量394 收藏 1
点赞数
分类专栏： NOIP总结 OI算法总结 文章标签： splay NOIP 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scar_lyw/article/details/53996350
版权

Splay（伸展树） 学习总结：

 

理解：

Splay是一种平衡二叉排序树， 复杂度均摊log n。

 

单点操作Splay要点：

1、动态内存静态化

实现：（内存池回收分配）：

template
   
   
    
    
struct memorypool 
{
    T buf[size], *tail, *st[size];
    int top;
    memorypool() : top(0), tail(buf) {}
    inline T *alloc() { return top ? st[--top] : tail++; }
    /*内存分配*/ 
    inline void recycle(T *p) { st[top++] = p; }
    /*内存回收*/ 
};

2、结点信息存储

实现：

struct node
{
	node *child[2], **root, *parent;
	/*child[]: 左右儿子, root: 根节点地址, 方便修改, parent: 父节点*/ 
	int count, size; /*count: 当前值个数, size: 以当前点为根的子树大小*/ 
	T value;
}

3、初始化结点

实现：

inline void init(node *parent, const T &value, node **root)
{
	this->parent = parent, this->root = root, this->value = value;
	this->count = 1, child[L] = NULL, child[R] = NULL;
}

4、删除节点

实现：

/*将前驱旋转到根，然后将后继旋转到前
驱的儿子，这时后继的左儿子为当前节点
，注意删除后维护节点信息*/
inline void erase(node *v)
{
	if(v->count != 1) return v->splay(), v->count--, v->maintain();
	node *precursor = v->precursor(), *successor = v->successor();
	precursor->splay(), successor->splay(precursor), successor->child[L]->recycle(pool);
	pool.recycle(successor->child[L]) , successor->child[L] = NULL;
	successor->maintain(), precursor->maintain();
}

5、旋转 & 旋转到根

实现

/*将自己旋转到原来的父亲的位置，将自己原来
的右儿子变为原来的父亲的左儿子，自己现在的
右儿子变为原来的父亲， 最后注意更新root*/
inline void rotate()
{
    Relation x = relation();
    node *oldparent = parent;
	if(oldparent->parent) oldparent->parent->child[oldparent->relation()] = this ;
	parent = oldparent->parent, oldparent->child[x] = child[x ^ 1];
	if(child[x ^ 1]) child[x ^ 1]->parent=oldparent;
	child[x ^ 1] = oldparent, oldparent->parent = this, oldparent->maintain(), maintain();
	if(!parent)  *root = this;
}

inline void splay(node *targetparent = NULL)
{
	while(parent != targetparent)
	{
		if(parent->parent == targetparent) rotate();
		else if(parent->relation() == relation()) parent->rotate(), rotate();
		else rotate(), rotate();
	}
}

6、求解前驱 &后继

实现

inline node *precursor()
{
    splay();
	node *v = child[L];
	while(v->child[R]) v = v->child[R];
	return v;
}
inline node *successor()
{
	splay();
	node *v = child[R];
	while(v->child[L]) v = v->child[L];
	return v;
}

7、选择第K小元素

实现：

/*最开始的边界有一个-INF注意加1*/
inline node *select(int k)
{
	k++;
	node *v = root;
	while(!(v->rank() < k && v->rank() + v->count >= k))
		v=(v->rank() >= k ? v->child[L] : (k -= v->rank() + v->count, v->child[R]));
	return v->splay(), v;
}

模板题目：

维护集合

题目背景

superOJ420

Source：

#include
   
   
    
    
#include
    
    
     
     
#include
     
     
      
      
#include
      
      
       
       
#include
       
       
         #include 
        
          #include 
         
           using namespace std; template 
          
            struct memorypool { T buf[size], *tail, *st[size]; int top; memorypool() : top(0), tail(buf) {} inline T *alloc() { return top ? st[--top] : tail++; } inline void recycle(T *p) { st[top++] = p; } }; const int MAXN = 1000000; template 
           
             struct Splay { enum Relation { L = 0, R = 1 }; struct node { node *child[2], **root, *parent; int count, size; T value; inline void init(node *parent, const T &value, node **root) { this->parent = parent, this->root = root, this->value = value; this->count = 1, child[L] = NULL, child[R] = NULL; } inline void recycle(memorypool 
            
              &pool) { if(child[L]) pool.recycle(child[L]); if(child[R]) pool.recycle(child[R]); } inline Relation relation() { return this == parent->child[L] ? L : R; } inline void maintain() { size = (child[L] ? child[L]->size : 0) + (child[R] ? child[R]->size : 0) + count; } inline void rotate() { Relation x = relation(); node *oldparent = parent; if(oldparent->parent) oldparent->parent->child[oldparent->relation()] = this ; parent = oldparent->parent, oldparent->child[x] = child[x ^ 1]; if(child[x ^ 1]) child[x ^ 1]->parent=oldparent; child[x ^ 1] = oldparent, oldparent->parent = this, oldparent->maintain(), maintain(); if(!parent) *root = this; } inline void splay(node *targetparent = NULL) { while(parent != targetparent) { if(parent->parent == targetparent) rotate(); else if(parent->relation() == relation()) parent->rotate(), rotate(); else rotate(), rotate(); } } inline node *precursor() { splay(); node *v = child[L]; while(v->child[R]) v = v->child[R]; return v; } inline node *successor() { splay(); node *v = child[R]; while(v->child[L]) v = v->child[L]; return v; } inline int rank() { return !child[L] ? 0 : child[L]->size; } } *root; memorypool 
             
               pool; Splay() : root(NULL) { insert(INF), insert(-INF); } inline node *find(const T &value) { node *v = root; while(v && value != v->value) v = (value < v->value ? v->child[L] : v->child[R]); return !v ? NULL : (v->splay(), v); } inline node *insert(const T &value) { node *v = find(value); if(v) return v->count++, v->maintain(), v; node **target = &root, *parent = NULL; while(*target) parent = *target, parent->size++, target = (value < parent->value ? &parent->child[L] : &parent->child[R]); return *target = pool.alloc(), (*target)->init(parent, value, &root), (*target)->splay(), root; } inline void erase(const T &value) { erase(find(value)); } inline void erase(node *v) { if(v->count != 1) return v->splay(), v->count--, v->maintain(); node *precursor = v->precursor(), *successor = v->successor(); precursor->splay(), successor->splay(precursor), successor->child[L]->recycle(pool); pool.recycle(successor->child[L]) , successor->child[L] = NULL; successor->maintain(), precursor->maintain(); } inline int rank(const T &value) { node *v = find(value); if(v) return v->rank(); else { v = insert(value); register int ans = v->rank(); return erase(v), ans; } } inline node *select(int k) { k++; node *v = root; while(!(v->rank() < k && v->rank() + v->count >= k)) v=(v->rank() >= k ? v->child[L] : (k -= v->rank() + v->count, v->child[R])); return v->splay(), v; } inline const T &precursor(const T &value) { node *v = find(value); if(v) return v->precursor()->value; else { v = insert(value); const T &ans = v->precursor()->value; return erase(v), ans; } } inline const T &successor(const T &value) { node *v = find(value); if(v) return v->successor()->value; else { v = insert(value); const T &ans = v->successor()->value; return erase(v),ans; } } }; inline void R(int &v) { char c = 0; bool p = true; v = 0; while(!isdigit(c)) { if(c == '-') p = false; c = getchar(); } while(isdigit(c)) { v = (v << 3) + (v << 1) + (c ^ '0'); c = getchar(); } if(!p) v = -v; } const int INF = ~0u>>1; Splay 
              
                splay; int n; int main() { R(n); while(n--) { int type, x, ans; R(type), R(x); switch(type) { case 0: splay.insert(x); break; case 1: splay.erase(x); break; case 2: cout << splay.select(x)->value << '\n'; break; case 3: cout << splay.rank(x) - 1 << '\n'; break; case 4: ans = splay.precursor(x); cout << (ans == -INF ? -1 : ans) << '\n'; break; case 5: ans = splay.successor(x); cout << (ans == INF ? -1 : ans) <<'\n'; break; } } return 0; }


区间操作Splay要点：

1、动态内存静态化 （同上）

2、节点信息存储

实现

struct node
{
	node *child[2], *parent, **root;
	int size;
	T value;
	bool reverse, bound;
	/*reverse:反转标记，bound:边界*/
}

3、建立边界

实现

/*左右边界*/
inline void buildbound(Relation x)
{
	node **v = &root, *parent = NULL;
	while(*v) parent = (*v), parent->size++, v = &parent->child[x];
	(*v) = pool.alloc(), (*v)->init(parent, &root, 0, true), (*v)->maintain();
}

4、提取区间

实现：

inline node *select(int k)
{
	k++;
	node *v = root;
	while(v->pushdown(), v->rank() + 1 != k) v = (v->rank() >= k ? v->child[L] : (k -= v->rank() + 1, v->child[R]));
	return v->splay(), v;
}
/*类比对于一个点的删除时的提取*/
inline node *&select(int l, int r)
{
	node *vl = select(l - 1), *vr = select(r + 1);
	return vl->splay(), vr->splay(vl), vr->child[L];
}

5、插入区间

实现：

inline node *buildrange(const T *a, int l, int r, node *parent)
{
	if(l > r) return NULL;
	register int mid = l + r >> 1;
	node *v = pool.alloc();
	v->init(parent, &root, a[mid - 1]);
	if(l != r) v->child[L] = buildrange(a, l, mid - 1, v), v->child[R] = buildrange(a, mid+1, r, v);
	return v->maintain(), v; 
}

inline void insert(int pos, const T *a, int n)
{
	node *&range = select(pos + 1, pos);
	range = buildrange(a, 1, n, root->child[R]);
	root->child[R]->maintain(), root->maintain();
}

6、删除区间

实现：

/*提取区间后，类比单点删除*/
inline void erase(int l, int r)
{
	node *&range = select(l, r);
	range->recycle(pool), pool.recycle(range), range = NULL;
	root->child[R]->maintain(), root->maintain();
}

7、区间反转

实现：

/*对于标记的处理和更新*/
inline void pushdown()
{
	if(reverse)
	{
		if(child[L]) child[L]->reverse ^= 1;
		if(child[R]) child[R]->reverse ^= 1;
		swap(child[L], child[R]), reverse = false;
	}
}

inline void reverse(int l, int r)
{
	node *range = select(l ,r);
	range->reverse ^= 1;
}

文本编辑器

题目背景

BZOJ1269

Source：

 

#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      
#include 
      
      
       
       
#include 
       
       
         #include 
        
          #include 
         
           using namespace std; inline void R(int &v) { char c = 0; bool p = true; v = 0; while(!isdigit(c)) { if(c == '-') p = false; c = getchar(); } while(isdigit(c)) { v = (v << 3) + (v << 1) + (c ^ '0'); c = getchar(); } if(!p) v = -v; } template 
          
            struct memorypool { T buf[size], *tail, *end, *st[size]; int top; memorypool() : top(0), tail(buf), end(buf + size) {} inline T *alloc() { if (top) return st[--top]; if (tail != end) return tail++; return new T; } inline void recycle(T *p) { if (top > size) delete p; else st[top++] = p; } }; const int MAXN = 1024 * 1024 * 4 ; const int MAX = 1024 * 1024 * 4 ; template 
           
             struct Splay { enum Relation { L = 0, R = 1 }; struct node { node *child[2], *parent, **root; int size; T value; bool reverse, bound; inline void init(node *parent, node **root, const T &value, bool bound = false) { this->parent = parent, this->root = root, this->value = value, this->bound = bound; this->reverse = false, this->size = 1, child[L] = child[R] = NULL; } inline void recycle(memorypool 
            
              &pool) { if(child[L]) pool.recycle(child[L]); if(child[R]) pool.recycle(child[R]); } inline void pushdown() { if(reverse) { if(child[L]) child[L]->reverse ^= 1; if(child[R]) child[R]->reverse ^= 1; swap(child[L], child[R]), reverse = false; } } inline Relation relation() { return this == parent->child[L] ? L : R; } inline void maintain() { pushdown(), size = (child[L] ? child[L]->size : 0) + (child[R] ? child[R]->size : 0) + 1; } inline void rotate() { if(parent->parent) parent->parent->pushdown(); parent->pushdown(), pushdown(); Relation x = relation(); node *oldparent = parent; if(oldparent->parent) oldparent->parent->child[oldparent->relation()] = this; parent = oldparent->parent, oldparent->child[x] = child[x ^ 1]; if(child[x ^ 1]) child[x ^ 1]->parent = oldparent; child[x ^ 1] = oldparent, oldparent->parent = this, oldparent->maintain(), maintain(); if(!parent) *root = this; } inline void splay(node *targetparent = NULL) { while(parent != targetparent) { if(parent->parent == targetparent) rotate(); else { parent->parent->pushdown(), parent->pushdown(); if(parent->relation() == relation()) parent->rotate(), rotate(); else rotate(), rotate(); } } } inline int rank() { return child[L] ? child[L]->size : 0; } inline int pos() { return splay(), child[L] ? child[L]->size : 0; } } *root; memorypool 
             
               pool; Splay() : root(NULL) { buildbound(L), buildbound(R); } inline node *buildrange(const T *a, int l, int r, node *parent) { if(l > r) return NULL; register int mid = l + r >> 1; node *v = pool.alloc(); v->init(parent, &root, a[mid - 1]); if(l != r) v->child[L] = buildrange(a, l, mid - 1, v), v->child[R] = buildrange(a, mid+1, r, v); return v->maintain(), v; } inline void buildbound(Relation x) { node **v = &root, *parent = NULL; while(*v) parent = (*v), parent->size++, v = &parent->child[x]; (*v) = pool.alloc(), (*v)->init(parent, &root, 0, true), (*v)->maintain(); } inline node *select(int k) { k++; node *v = root; while(v->pushdown(), v->rank() + 1 != k) v = (v->rank() >= k ? v->child[L] : (k -= v->rank() + 1, v->child[R])); return v->splay(), v; } inline node *&select(int l, int r) { node *vl = select(l - 1), *vr = select(r + 1); return vl->splay(), vr->splay(vl), vr->child[L]; } inline void erase(int l, int r) { node *&range = select(l, r); range->recycle(pool), pool.recycle(range), range = NULL; root->child[R]->maintain(), root->maintain(); } inline void insert(int pos, const T *a, int n) { node *&range = select(pos + 1, pos); range = buildrange(a, 1, n, root->child[R]); root->child[R]->maintain(), root->maintain(); } inline void reverse(int l, int r) { node *range = select(l ,r); range->reverse ^= 1; } inline int size() { return root->size - 2; } }; Splay 
              
                splay; int main() { static char type[10], a[MAX], c; static int x, pos, n; R(n); while(n--) { scanf("%s", type); if(type[0] == 'I') { R(x); int cnt = 0; while(true) { c = getchar(); if(c >= 32 && c <= 126) a[cnt++] = c; if(cnt == x) break; } splay.insert(pos, a, x); } else if(type[0] == 'M') R(x), pos = x; else if(type[0] == 'D') R(x), splay.erase(pos + 1, pos + x); else if(type[0] == 'R') R(x), splay.reverse(pos + 1, pos + x); else if(type[0] == 'G') cout << splay.select(pos + 1)->value << '\n'; else if(type[0] == 'P') pos--; else if(type[0] == 'N') pos++; } return 0; }

 

Summary：

Splay是目前流行的平衡树算法之一， 在做题中有着非常广泛的应用， 但是常数大也是一个严重的问题， 所以本蒟蒻就强行学习了神犇的Splay纯指针写法，%%%Menci， 现在数据结构在OI中的比重越来越大，所以唯有不断理解学习才是王道。

参考：https://oi.men.ci/splay-template/

scarlyw
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
关于Splay的学习感受
Michael_GLF的博客
10-03 254
                                        【关于Splay】 之前记得五月份听过一次外省金牌选手讲过一次，然后七月份又讲过一次，但本人脑子比较笨，当时完全听得一脸懵逼啊，练了两个月确实不一样，现在谈一下学习Splay的一些感受。 首先欲知Splay为何物，不得不先讲讲它的祖宗：二叉查找树，即BST（Binary Search Tree），关于二叉查找树，...
线段树总结
09-30
标题中的“线段树总结”指的是对线段树这一数据结构的全面回顾和深入理解。描述中提到的“线段树很早前写的那篇文章”可能是一篇关于线段树的经典教程，作者发现原来的代码风格不够优雅，因此决定重新编写并加入新的...
Splay学习总结
Zero's World
12-28 368
Splay学习总结
splay模板（功能最全）
huzujun的博客
08-03 3736
回想起来splay大概是高中时的噩梦吧，手敲splay的确挑战太大了，不过到了acm时期，其实应该是不用惧怕splay的，把板子准备好就问题不大。 poj3580 虽然不是最简单的题，但是可以作为板子题 https://vjudge.net/problem/POJ-3580 题目大意： 要求实现一种数据结构，支持对一个数字序列的 6 种操作： ADD x y val：第 x...
[总结] Splay学习小结
Chlience的博客
12-28 303
万分感谢Clove_unique学长给我的启发 变量声明： f[i]表示i的父节点，ch[i][0]表示i的左儿子，ch[i][1]表示i的右儿子，key[i]表示i节点所代表的值，cnt[i]表示key[i]出现的次数（我们将所有值相同的点缩为一个点），size[i]表示i及其子树的大小，sz为整棵树的大小，root为根节点标号 基本性质： 平衡树中的每个节点的左儿子都小于它本身
Splay 总结基础精华
Jerry_wang119的博客
07-01 2788
前言：第一次学习Splay是2月份，打板子的时候是3月份，Ac是4月份，写这篇博客是6月初；原因是因为我竟然发现我忘了Splay的板子了！很慌，必须总结一下！不敢说是最详细的，但希望对看到这篇博客的人有帮助。开始：Splay是处理序列问题的有力工具，并且是一个树形结构的数据结构；主要运用于需要区间删除，插入，翻转，查询，以及数据结构的嵌套等题目中……Splay是如何保存某一个序列中每一个元素的呢？...
Splay 学习笔记
weixin_30674525的博客
04-24 51
前言 伸展树（英语：Splay Tree）是一种能够自我平衡的二叉查找树，它能在均摊O(log n)的时间内完成基于伸展（Splay）操作的插入、查找、修改和删除操作。 众所周知，普通BST在进行各种操作时很容易因为左子树与右子树高度差的问题导致时间复杂度退化为O(n)，Splay为了避免这个问题，使用了一种叫做“伸展”的操作来使左右子树平衡，在后面会介绍。 定义 节点 node.v：节...
splay学习笔记及模板
Quack
11-22 1668
splay很灵活的，它既可以作为一棵二叉查找树又可以作为一棵区间树，不过不能共存。 因此从两方面来说splay。 一、splay的rotate，splay操作 splay不是特别平衡。不过splay还算是平衡树吧，是有维护平衡的方式的。 splay维护平衡的方式就是提根。查询完了某个节点，就把这个节点提根。这样经过证明每次操作是均摊log(n)的。 提根就是不停旋转，一次旋转，目标节点总可
平衡树Splay学习
fcdljh的博客
03-21 208
Splay平衡树模板：变量声明：f[i]表示i的父结点，ch[i][0]表示i的左儿子，ch[i][1]表示i的右儿子，key[i]表示i的关键字（即结点i代表的那个数字），cnt[i]表示i结点的关键字出现的次数（相当于权值），size[i]表示包括i的这个子树的大小；sz为整棵树的大小，root为整棵树的根。再介绍几个基本操作：【clear操作】：将当前点的各项值都清0（用于删除之后）void...
伸展树的基本操作与应用
03-24
### 伸展树的基本操作与应用 #### 引言 伸展树，又称Splay Tree，是由Daniel Sleator和Robert Tarjan在1985年...无论是对于数据结构的学习者还是专业领域的开发者，理解伸展树的工作原理和应用场景都是极为有价值的。
2019清华计算机912综合回忆版.pdf
09-19
- 伸展树（Splay Tree）：伸展树是一种自调整的二叉查找树，如果访问遵循局部性原理，它的平均操作时间复杂度可以达到O(logn)，否则可能不是O(logn)。 - KMP算法：KMP算法在不使用改进的next[]数组时，仍然可以...
数据结构课程设计--平衡二叉树的动态演示
06-29
常见的平衡二叉树类型包括AVL树、红黑树、Splay树等。 首先，我们来了解平衡二叉树的基本操作： 1. 插入：在平衡二叉树中插入节点时，需要保证树的平衡性。如果插入操作导致树失去平衡，就需要进行相应的旋转操作...
优秀而强行的十进制快速幂
scarlyw的博客
04-14 3003
十进制快速幂 & 快速幂
NOIP赛前总结
scarlyw的博客
11-16 1112
NOIP赛前总结 基础算法： ·（o）排序 ·（?）贪心（注意每一次写拍，验证思想） ·（o）二分答案（注意边界，对拍验证，自己出极值） ·（o）逆序对（树状数组） ·（o）离散化（排序） ·（?）倍增（注意使用的范围和方法） ·（?）三分答案   数学问题： ·（o）公约数&公倍数 ·（X）素数问题+莫比乌斯+欧拉函数（线筛板子） ·（o）gcd & ext_gcd（
中国剩余定理学习总结
scarlyw的博客
04-14 888
中国剩余定理
欧拉回路学习总结
scarlyw的博客
01-29 703
欧拉回路学习总结   理解： 设G = (V, E)是一个图。 欧拉回路 图G中经过每条边一次并且仅一次的回路称作欧拉回路。 欧拉路径 图G中经过每条边一次并且仅一次的路径称作欧拉路径。 欧拉图 存在欧拉回路的图称为欧拉图。 半欧拉图 存在欧拉路径但不存在欧拉回路的图称为半欧拉图。   思想：  首先明确一点，如果原图存在孤立点，那么我们去除孤立点不会对答案有所影响，然后我们
可持久化splay 学习笔记
最新发布
08-26
2. 学习如何构建可持久化splay树，包括复制节点、更新版本和保存历史版本等。 3. 掌握可持久化splay树的常见应用场景，比如区间修改和区间查询等。 4. 深入了解与可持久化splay树相关的其他数据结构和算法，比如可...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值