Splay伸展树模板总结

最新推荐文章于 2024-03-28 10:46:50 发布
最新推荐文章于 2024-03-28 10:46:50 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snk1996/article/details/48210045
版权

1.基本点操作

//Splay 基本操作 均摊复杂度O(lgN) 

//POJ 1442
//基本点操作


// sp.init()	初始化



#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

#define maxn 31000
#define min(a,b) ((a)<(b)?(a):(b))
const int oo = 0x3f3f3f3f;
struct Node{
    int key, sz, cnt;
    Node *ch[2], *pnt;//左右儿子和父亲
    Node(){}
    Node(int x, int y, int z){
    key = x, sz = y, cnt = z;
    }
    void rs(){
    sz = ch[0]->sz + ch[1]->sz + cnt;
    }
}nil(0, 0, 0), *NIL = &nil;
struct Splay{//伸展树结构体类型
    Node *root;
    int ncnt;//计算key值不同的结点数，注意已经去重了
    Node nod[maxn];
    void init(){// 首先要初始化
        root = NIL;
        ncnt = 0;
    }
    void rotate(Node *x, bool d){//旋转操作，d为true表示右旋
        Node *y = x->pnt;
        y->ch[!d] = x->ch[d];
        if (x->ch[d] != NIL)
            x->ch[d]->pnt = y;
        x->pnt = y->pnt;
        if (y->pnt != NIL){
            if (y == y->pnt->ch[d])
                y->pnt->ch[d] = x;
            else
                y->pnt->ch[!d] = x;
        }
        x->ch[d] = y;
        y->pnt = x;
        y->rs();
        x->rs();
    }
    void splay(Node *x, Node *target){//将x伸展到target的儿子位置处
        Node *y;
        while (x->pnt != target){
            y = x->pnt;
            if (x == y->ch[0]){
                if (y->pnt != target && y == y->pnt->ch[0])
                    rotate(y, true);
                    rotate(x, true);
            }
            else{
                if (y->pnt != target && y == y->pnt->ch[1])
                    rotate(y, false);
                    rotate(x, false);
            }
        }
        if (target == NIL)
            root = x;
    }
    /************************以上一般不用修改************************/
    void insert(int key){//插入一个值
        if (root == NIL){
            ncnt = 0;
            root = &nod[++ncnt];
            root->ch[0] = root->ch[1] = root->pnt = NIL;
            root->key = key;
            root->sz = root->cnt = 1;
            return;
        }
        Node *x = root, *y;
        while (1){
            x->sz++;
            if (key == x->key){
                x->cnt++;
                x->rs();
                y = x;
                break;
            }
            else if (key < x->key){
                    if (x->ch[0] != NIL)
                        x = x->ch[0];
                    else{
                        x->ch[0] = &nod[++ncnt];
                        y = x->ch[0];
                        y->key = key;
                        y->sz = y->cnt = 1;
                        y->ch[0] = y->ch[1] = NIL;
                        y->pnt = x;
                        break;
                    }
            }
            else{
                if (x->ch[1] != NIL)
                    x = x->ch[1];
                else{
                    x->ch[1] = &nod[++ncnt];
                    y = x->ch[1];
                    y->key = key;
                    y->sz = y->cnt = 1;
                    y->ch[0] = y->ch[1] = NIL;
                    y->pnt = x;
                    break;
                }
            }
        }
        splay(y, NIL);
    }
    Node* search(int key){//查找一个值，返回指针
        if (root == NIL)
            return NIL;
        Node *x = root, *y = NIL;
        while (1){
            if (key == x->key){
                y = x;
                break;
            }
            else if (key > x->key){
                if (x->ch[1] != NIL)
                x = x->ch[1];
                else
                    break;
            }
            else{
                if (x->ch[0] != NIL)
                    x = x->ch[0];
                else
                    break;
            }
        }
        splay(x, NIL);
        return y;
    }
    Node* searchmin(Node *x){//查找最小值，返回指针
        Node *y = x->pnt;
        while (x->ch[0] != NIL){//遍历到最左的儿子就是最小值
            x = x->ch[0];
        }
            splay(x, y);
            return x;
    }
    Node* searchmax(Node *x){
		Node *y = x->pnt;
		while(x->ch[1] != NIL){
			x = x->ch[1];
		} 
			splay(x,y);
			return x;
	} 
    void del(int key){//删除一个值
        if (root == NIL)
            return;
        Node *x = search(key), *y;
        if (x == NIL)
            return;
        if (x->cnt > 1){
            x->cnt--;
            x->rs();
            return;
        }
        else if (x->ch[0] == NIL && x->ch[1] == NIL){
            init();
            return;
        }
        else if (x->ch[0] == NIL){
            root = x->ch[1];
            x->ch[1]->pnt = NIL;
            return;
        }
        else if (x->ch[1] == NIL){
            root = x->ch[0];
            x->ch[0]->pnt = NIL;
            return;
        }
        y = searchmin(x->ch[1]);
        y->pnt = NIL;
        y->ch[0] = x->ch[0];
        x->ch[0]->pnt = y;
        y->rs();
        root = y;
    }
    int rank(int key){//求结点高度
        Node *x = search(key);
        if (x == NIL)
            return 0;
        return x->ch[0]->sz + 1/* or x->cnt*/;
    }
    Node* findk(int kth){//查找第k小的值
        if (root == NIL || kth > root->sz)
            return NIL;
        Node *x = root;
        while (1){
            if (x->ch[0]->sz +1 <= kth && kth <= x->ch[0]->sz + x->cnt)
                break;
            else if (kth <= x->ch[0]->sz)
                x = x->ch[0];
            else{
                kth -= x->ch[0]->sz + x->cnt;
                x = x->ch[1];
            }
        }
        splay(x, NIL);
        return x;
    }
    
    Node* proc(int key)
    {
		Node *x = search(key);
		if(x==NIL || x->cnt == 1 && x->ch[0]==NIL)
		{
			return NIL;	
		}
		if(x->cnt > 1)
		{
			return x;
		}
		else
		{
			return searchmax(x->ch[0]);
		}
	}
	
	Node* succ(int key)
	{
		Node *x = search(key);
		if(x==NIL || x->cnt == 1 && x->ch[1]==NIL)
		{
			return NIL;
		}
		if(x->cnt > 1)
		{
			return x;
		}
		else
		{
			return searchmin(x->ch[1]);
		}
	}
	
	int size()
	{
		return root->sz;
	}
}sp;
int num[30010];
int cmd[30010];
int main(){
   	
   	ios::sync_with_stdio(false);
	int N,M,x,i;
	while(cin >> N >> M)
	{
		sp.init();
		for(int i=0;i<N;i++)
		{
			cin >> num[i];
		}
		for(int i=1;i<=M;i++)
		{
			cin >> cmd[i];
		}
		int j=1;
		Node* node;
		for(int i=0;i<N;i++)
		{
			sp.insert(num[i]);
			while(sp.size()==cmd[j])
			{
				node = sp.findk(j++);
				cout << node->key << endl;
			}
		}
		
	}
   	
    return 0;
}

2.基本区间操作 

/*
_http://acm.hdu.edu.cn/showproblem.php?pid=3487_
1.区间切割 区间翻转      
原序列:	1、2、3 ……n 
rangeCut(a,b,c)	将[ath,bth]剪切掉 然后黏贴到新序列的第cth后面 
rangeFlip(a,b)	翻转[ath,bth] 



_http://acm.hdu.edu.cn/showproblem.php?pid=1754_
2.单点更新 区间询问最值 	
query(a,b)	询问[a,b]最大值
update(a,c)	更新学生a的成绩为c 



_http://poj.org/problem?id=3468_
3.区间更新 区间求和
querySum(l,r)	询问[l,r]的和 
updateInterval(l,r,c)	区间[l,r]的值+c 

*/ 
#include<iostream>
#include<cstdio>
#include<cstring>
#define LL long long
using namespace std;
const int MAXN = 333333;
#define m_set(ptr,v,type,size) memset(ptr,v,sizeof(type) * size)
#define loop(begin,end) for(int i=begin;i<end;i++)
#define debug	puts("here!")
class SplayTree
{
	#define l(x) (ch[x][0])
	#define r(x) (ch[x][1])
	#define mid(x,y)	((x+y)>>1)
	public:
		int ch[MAXN][2],pre[MAXN];
		int sz[MAXN],val[MAXN],rev[MAXN],a[MAXN];
		int root,tot;
		
		/**************/
		
		int mx[MAXN];
		
		/**************/ 
		
		LL sum[MAXN],add[MAXN];
		
		/**************/
		
		void init()
		{
			m_set(ch,0,int,MAXN*2);
			m_set(pre,0,int,MAXN);
			m_set(sz,0,int,MAXN);
			m_set(val,0,int,MAXN);
			m_set(rev,0,int,MAXN);
			
			/*************/
			m_set(mx,-1,int,MAXN);
			/*************/
			root = tot = 0;
		}
		
		void read(int n)		//0 1 2 3 .... n 0
		{
			a[1] = a[n+2] = -1;
//			loop(2,n+2){
//				a[i] = i - 1;
//			}	

			/*************/
			for(int i=2;i<=n+1;i++)
			{
				scanf("%d",&a[i]);
			}
			/*************/
		}
		
		void push_up(int rt)
		{
			sz[rt] = sz[l(rt)] + sz[r(rt)] + 1;
			/*************/
			mx[rt] = max(max(mx[l(rt)],mx[r(rt)]),val[rt]);
			/*************/
			sum[rt] = sum[l(rt)] + sum[r(rt)] + val[rt];
		} 
		
		void push_down(int rt)
		{
//			if(rt&&rev[rt])
//			{
//				swap(l(rt),r(rt));
//				if(l(rt))	rev[l(rt)] ^= 1;
//				if(r(rt))	rev[r(rt)] ^= 1;
//				rev[rt] = 0;
//			}
		
			if(add[rt])
			{
				if(l(rt))
				{
					val[l(rt)] += add[rt];
					add[l(rt)] += add[rt];
					sum[l(rt)] += add[rt] * sz[l(rt)];
				}
				if(r(rt))
				{
					val[r(rt)] += add[rt];
					add[r(rt)] += add[rt];
					sum[r(rt)] += add[rt] * sz[r(rt)]; 
				}
				add[rt] = 0;
			}			
		}
			
		void swap(int &x,int &y)
		{
			int tmp = x;
			x = y;
			y = tmp;
		}
		
	
		void rotate(int x,int f)	//将x旋转到其直接父节点 右旋 左旋 
		{
			int y  = pre[x];
			push_down(x);
			push_down(y);
			ch[y][!f] = ch[x][f];
			if(ch[y][!f])	pre[ch[y][!f]] = y;
			push_up(y);
			if(pre[y])	ch[pre[y]][r(pre[y])==y]= x;
			pre[x] = pre[y];
			ch[x][f] = y;
			pre[y] = x;
		}
		
		void splay(int x,int goal)	//将x旋转到以goal节点为父节点 
		{
			push_down(x);
			while(pre[x]!=goal)
			{
				int y = pre[x] , z = pre[pre[x]]; 
				if(z==goal)
				{
					rotate(x,l(y)==x);
				}
				else
				{
					int f = (l(z) == y);
					if(ch[y][!f] == x)
					{
						rotate(y,f);
						rotate(x,f);
					}
					else
					{
						rotate(x,!f);
						rotate(x,f);
					}
				}
			} 
			push_up(x);
			if(goal==0)	root = x;
		}
		
		void rotateTo(int k,int goal)
		{
			int x = root;
			while(true)
			{
				push_down(x);
				int tmp = sz[l(x)] + 1;
				if(k==tmp)	break;
				else if(k<tmp)	x = l(x);
				else
				{
					k -= tmp;
					x = r(x);
				}
			}
			splay(x,goal);
		}
		
		void buildTree(int l,int r,int &rt,int f)
		{
			if(l>r)	return;
			int m = mid(l,r);
			rt = ++tot;
			val[rt] = a[m];
			pre[rt] = f;
			buildTree(l,m-1,l(rt),rt);
			buildTree(m+1,r,r(rt),rt);
			push_up(rt);
		}
		
		void rangeCut(int l,int r,int goal)
		{
			rotateTo(l-1,0);
			rotateTo(r+1,root);
			push_down(r(root));
			int x = l(r(root));	//x子树代表[l,r]区间
			//截取 
			l(r(root)) = 0;	
			pre[x] = 0; 
			push_up(r(root));
			push_up(root);
			rotateTo(goal,0);
			rotateTo(goal+1,root);
			push_down(r(root));
			l(r(root)) = x;
			pre[x] = r(root);
			push_up(r(root));
			push_up(root); 
		}
		
		void rangeFlip(int l,int r)
		{
			rotateTo(l-1,0);
			rotateTo(r+1,root);
			push_down(r(root));
			int x = l(r(root));
			rev[x] ^= 1;		
		}
		
		void dfs(int rt,int &size)
		{
			if(!rt)	return;
			push_down(rt);
			dfs(l(rt),size);
			a[size++] = val[rt];
			dfs(r(rt),size);
		} 
		
		
		/********************/
		int query(int l,int r)
		{
			rotateTo(l-1,0);
			rotateTo(r+1,root);
			return mx[l(r(root))];
		} 
		
		void update(int pos,int c)
		{
			rotateTo(pos,0);
			val[root] = c;
			push_up(root);
		}
		
		LL querySum(int l,int r)
		{
			rotateTo(l-1,0);
			rotateTo(r+1,root);
			return sum[l(r(root))];
		} 
		
		void updateInterval(int l,int r,int c)
		{
			rotateTo(l-1,0);
			rotateTo(r+1,root);
			val[l(r(root))] += c;
			sum[l(r(root))] += c * sz[l(r(root))];
			add[l(r(root))] += c;
		}
		
}spt;

//int main()
//{
//	int n,m;
//	while(~scanf("%d%d",&n,&m) && (n>=0 || m>=0))
//	{
//		spt.init();
//		spt.read(n); 
//		spt.buildTree(1,n+2,spt.root,0);
//		char op[5];
//		int a,b,c;
//		while(m--)
//		{
//			scanf("%s%d%d",op,&a,&b);
//			if(op[0]=='C')
//			{
//				scanf("%d",&c);
//				spt.rangeCut(a+1,b+1,c+1);	//因为哨兵0 多加1
//			}
//			else
//			{
//				spt.rangeFlip(a+1,b+1);
//			}
//		}
//		n = 0;
//		spt.dfs(spt.root,n);	//中序遍历即为序列结果 
//		loop(1,n-1)
//		{
//			if(i!=1)	printf(" ");
//			printf("%d",spt.a[i]);
//		}
//		printf("\n");
//	}
//	return 0;
//}





//int main()
//{
//	int n,m;
//	while(scanf("%d%d",&n,&m) == 2)
//	{
//		spt.init();
//		spt.read(n);
//		spt.buildTree(1,n+2,spt.root,0);
//		char op[2];
//		int a,b;
//		while(m--)
//		{
//			scanf("%s%d%d",op,&a,&b);
//			if(op[0]=='Q')
//			{
//				printf("%d\n",spt.query(a+1,b+1));
//			}
//			else
//			{
//				spt.update(a+1,b);
//			}
//		}
//	}
//	return 0;
//} 



int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		spt.init();
		spt.read(n);
		spt.buildTree(1,n+2,spt.root,0);
		char op[2];
		int a,b,c;
		while(m--)
		{
			scanf("%s%d%d",op,&a,&b);
			if(op[0] == 'Q')
			{
				printf("%I64d\n",spt.querySum(a+1,b+1));
			}
			else
			{
				scanf("%d",&c);
				spt.updateInterval(a+1,b+1,c);
			}
		}
	}
	return 0;
}


snk1996
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【模板】Splay
lsy_41的博客
03-10 251
Splay
bzoj1500（妥妥的splay模板题）
cq_phqg
09-04 1639
1500: [NOI2005]维修数列 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 6366  Solved: 1910 [Submit][Status] Description Input 输入文件的第1行包含两个数N和M，N表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。以下
Splay树【模板】
hwy0622的博客
04-15 93
Splay树
P3369 【模板】普通平衡树（splay 算法）
最新发布
zhi6fui的博客
03-28 682
比如：x右旋，x的右儿子为y,这时原本的x的右儿子就要当y的左儿子。第一行为 n，表示操作的个数,下面 n 行每行有两个数 opt 和 x，opt 表示操作的序号（1≤opt≤6）我们找到它的前驱和后继，再进行把删除的点移到其后继的左儿子上，再进行删除操作。我们自己构造平衡二叉树，左儿子节点小于父节点，右儿子的全部节点大于父节点。而且x为y的左儿子，x的任意一个儿子一定小于其x的父节点。当直线型时，先旋转它的父节点，在旋转它自己本身。在遍历它的左儿子的右儿子。右旋时：x的右儿子当作y的左儿子。
伸展树模板
he_qingjun的博客
08-19 131
题目链接：https://www.luogu.com.cn/problem/T142843 伸展树这块知识要掌握左旋和右旋，以及splay中四种调用左旋右旋的情况，通过伸展会把x节点提升至根节点的位置，理解了这些差不多就会了。 这里有个大佬也写了——》https://www.luogu.com.cn/paste/k0h4zdjy 下面是我把实现的模板 //题目：https://www.luogu.com.cn/problem/T142843 //参考代码：https://www.luogu.com.cn/p
伸展树
weixin_34203832的博客
03-17 204
一、简介：伸展树，或者叫自适应查找树，是一种用于保存有序集合的简单高效的数据结构。伸展树实质上是一个二叉查找树。允许查找，插入，删除，删除最小，删除最大，分割，合并等许多操作，这些操作的时间复杂度为O(logN)。由于伸展树可以适应需求序列，因此他们的性能在实际应用中更优秀。伸展树支持所有的二叉树操作。伸展树不保证最坏情况下的时间复杂度为O(logN)。伸展树的时间复杂度边界是均摊的。尽管一个单独...
Splay伸展树结构体模板
01-06
Splay结构体的模板，含有各种旋转、插入、翻转等操作，注释清晰
splay 伸展树.ppt
09-17
splay 伸展树.ppt
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
Splay（伸展树）模板
01-10
Splay模板包括旋转，主函数Splay，插入，删除，最大值，最小值，查询k大，查询排名
C++伸展树实现.zip
08-20
C++伸展树实现
splay学习笔记及模板
Quack
11-22 1659
splay很灵活的，它既可以作为一棵二叉查找树又可以作为一棵区间树，不过不能共存。 因此从两方面来说splay。 一、splay的rotate，splay操作 splay不是特别平衡。不过splay还算是平衡树吧，是有维护平衡的方式的。 splay维护平衡的方式就是提根。查询完了某个节点，就把这个节点提根。这样经过证明每次操作是均摊log(n)的。 提根就是不停旋转，一次旋转，目标节点总可
BZOJ3223&3224 文艺&普通平衡树 Splay模板（数组）
DaD3zZ ， To be a Beyonder！
03-22 1031
才发现自己splay的模板又臭又长，还自带大常数，而且指针不会调，换回数组，从新打了一遍 区间翻转：#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> using namespace std; int read() { int x=0,f=1; char ch=ge
数据结构与算法分析之伸展树(splaytree)
mu0206mu的专栏
04-15 6540
1.伸展树，它保证从空树开始任意连续M次对树的操作最多花费O(MlogN)的时间。 2.伸展树的基本思想是，当一个节点a被访问后，通过一系列的AVL树的旋转将a移动到根节点上，这样下次访问时会被快速击中 只需要O(1)的时间。通常一个节点被访问时，它就很可能不久再次被访问。 3.构造伸展树的一个简单方法是从下向上进行单旋转，也就是将访问路径上的每个节点和他们的父节点都实施旋转
uva 11922 （伸展树模板题）
yjt9299的博客
07-27 350
给你一个长度为n 的序列（初始值为1到n）。有m 次操作，每次操作有l  r 你需要将l 到 r 的数字翻转。然后放到最后 m次操作后输出答案。 代码： #include&lt;bits/stdc++.h&gt; using namespace std; const int inf =0x3f3f3f3f; struct Node { Node *ch[2]; int s,v,f...
无比强大的数据结构 伸展树总结
努力奋斗才能梦想成真
09-30 3870
链接 ：http://www.notonlysuccess.com/index.php/splay-tree/ 论文链接：http://www.docin.com/p-62465596.html 其实本来不想学splay树的，因为好像平时做题不怎么用到，但是，请注意，书到用时方恨少啊，多一点储备，就多一分机会 论文里说，动态树也要用splay来维护的说，有的斜率优化的题也要用spla
HDU 1166 敌兵布阵 伸展树splay简单练手题
弱智就要多努力
10-23 711
题目：http://acm.hdu.edu.cn/showproblem.php?pid=1166题意：C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发
POJ 3580 splay模板题
~~Free planet 跳动的行星
08-16 532
POJ3580 splay
用C++写一个splay平衡树
02-19
我不是很熟悉C语言，但是我可以给你一些关于splay平衡树的基本知识：splay平衡树是一种二叉搜索树，它的特点是能够将最近使用的元素放在树的顶层，以提高查询效率。它的搜索过程和普通二叉搜索树类似，但是它会在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值