Splay树（插入、删除、区间最大字段和）—— SPOJ - GSS6 Can you answer these queries VI

最新推荐文章于 2019-08-23 10:23:38 发布
最新推荐文章于 2019-08-23 10:23:38 发布
阅读量1.1k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013351484/article/details/46957327
版权

对应题目：点击打开链接

SPOJ - GSS6
Can you answer these queries VI
Time Limit: 298MS Memory Limit: 1572864KB 64bit IO Format: %lld & %llu

 Status

Description

Given a sequence A of N (N <= 100000) integers, you have to apply Q (Q <= 100000) operations:

Insert, delete, replace an element, find the maximum contiguous(non empty) sum in a given interval.

Input

The first line of the input contains an integer N.
The following line contains N integers, representing the starting
sequence A1..AN, (|Ai| <= 10000).

The third line contains an integer Q. The next Q lines contains the operations in following form:

I x y: insert element y at position x (between x - 1 and x).
D x  : delete the element at position x.
R x y: replace element at position x with y.
Q x y: print max{Ai + Ai+1 + .. + Aj | x <= i <= j <= y}.

All given positions are valid, and given values are between -10000 and +10000.

The sequence will never be empty.

Output

For each "Q" operation, print an integer(one per line) as described above.

Example

Input:
5
3 -4 3 -1 6
10
I 6 2
Q 3 5
R 5 -4
Q 3 5
D 2
Q 1 5
I 2 -10
Q 1 6
R 2 -1
Q 1 6

Output:
8
3
6
3
5

题意：

开始有n个数，位置从1到n，

(I  a,  b) 表示在a位置插入数值b，

(D   a) 表示把a位置的数删掉，

(R  a,  b) 表示把a位置的数换成数值b

(Q  a,  b) 表示求a位置到b位置之间的最大连续字段和


思路：

伸展树基本操作，结点信息有子树和sum,  前缀最大连续和lsum,  后缀最大连续和rsum,  子树最大连续和msum。主要是在push_up()的地方要注意下，认真仔细。


数组型：

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#define MAX(x, y) ((x)>(y)?(x):(y))
const int MAXN=200020;
using namespace std;

struct SplayTree
{
	int val[MAXN];
	int c[MAXN>>1];
	int sz[MAXN];
	int Left[MAXN];
	int Right[MAXN];
	int fa[MAXN];
	int msum[MAXN];
	int lsum[MAXN];
	int rsum[MAXN];
	int sum[MAXN];
	int rt, Size, nil, inf;

	SplayTree()
	{
		rt = Size = nil = 0;
		inf = 1000000000;
	}

	inline void Push_up(int T)
	{
		sz[T] = sz[Left[T]] + sz[Right[T]] + 1;
		sum[T] = sum[Left[T]] + sum[Right[T]] + val[T];
		msum[T] = lsum[T] = rsum[T] = val[T];
		lsum[T] = MAX(lsum[Left[T]], sum[Left[T]] + val[T] + MAX(lsum[Right[T]], 0));
		rsum[T] = MAX(rsum[Right[T]], sum[Right[T]] + val[T] + MAX(rsum[Left[T]], 0));
		msum[T] = MAX(MAX(msum[Left[T]], msum[Right[T]]), val[T] + MAX(lsum[Right[T]], 0) + MAX(rsum[Left[T]], 0));
	}

	void R_rotate(int x)  
	{  
		int y = fa[x];  
		int z = fa[y];  
		int k = Right[x];  
		Left[y] = k;  
		Right[x] = y;  
		if(nil != z){  
			if(y == Left[z]) Left[z] = x;  
			else Right[z] = x;  
		}  
		if(nil != k) fa[k] = y;  
		fa[y] = x;  
		fa[x] = z;  
		Push_up(y);
	}  
	  
	void L_rotate(int x)  
	{  
		int y = fa[x];  
		int z = fa[y];  
		int k = Left[x];  
		Right[y] = k;  
		Left[x] = y;  
		if(nil != z){  
			if(y == Right[z]) Right[z] = x;  
			else Left[z] = x;  
		}  
		if(nil != k) fa[k] = y;  
		fa[y] = x;  
		fa[x] = z;  
		Push_up(y);
	}  

	int FindTag(int x)  
	{  
		if(nil == rt) return nil;  
		int p = rt;  
		int sum = sz[Left[p]] + 1;  
		while(sum != x)  
		{  
			if(sum < x){  
				p = Right[p];  
				x -= sum;  
			}  
			else p = Left[p];  
			if(nil == p) break;
			sum = sz[Left[p]] + 1;  
		}  
		return p;  
	}  
	
	void Splay(int x, int &T)  
	{  
		int p, end;  
		end = fa[T];  
		while(end != fa[x])  
		{  
			p = fa[x];  
			if(end == fa[p]){ //p是根结点  
				if(x == Left[p]) R_rotate(x);  
				else L_rotate(x);  
				break;  
			}  
			//p不是根结点  
			if(x == Left[p]){  
				if(p == Left[fa[p]]){  
					R_rotate(p); //LL  
					R_rotate(x); //LL  
				}  
				else{  
					R_rotate(x); //RL  
					L_rotate(x);  
				}  
			}  
			else{  
				if(p == Right[fa[p]]){ //RR  
					L_rotate(p);  
					L_rotate(x);  
				}  
				else{ //LR  
					L_rotate(x);  
					R_rotate(x);  
				}  
			}  
		}  
		T = x;  
		Push_up(T);
	}  

	inline void NewNode(int pre, int &T, int v)
	{
		T = ++ Size;
		fa[T] = pre;
		sz[T] = 1;
		Left[T] = Right[T] = nil;
		sum[T] = msum[T] = lsum[T] = rsum[T] = val[T] = v;
	}

	void MakeTree(int &T, int pre, int x, int y)
	{
		if(x > y) return;
		int mid = ((x + y)>>1);
		NewNode(pre, T, c[mid]);
		MakeTree(Left[T], T, x, mid - 1);
		MakeTree(Right[T], T, mid + 1, y);
		Push_up(T);
	}
		
	void Init(int n)
	{
		Left[0] = Right[0] = fa[0] = nil;
		sum[0] = 0;
		msum[0] = lsum[0] = rsum[0] = -inf;
		Size = 0;
		NewNode(nil, rt, -inf);
		NewNode(rt, Right[rt], inf);
		sz[rt] = 2;
		fa[rt] = 0;
		fa[rt] = nil;
		fa[Right[rt]] = rt;
		int i;
		for(i = 0; i < n; i++) scanf("%d", c + i);
		MakeTree(Left[Right[rt]], Right[rt], 0, n - 1);
		Push_up(Right[rt]);
		Push_up(rt);
	}

	void Insert(int pos, int v)
	{
		int t;
		t = FindTag(pos);
		Splay(t, rt);
		t = FindTag(pos + 1);
		Splay(t, Right[rt]);
		NewNode(Right[rt], Left[Right[rt]], v);
		Push_up(Right[rt]);
		Push_up(rt);
	}

	void Delete(int pos)
	{
		int t;
		t = FindTag(pos);
		Splay(t, rt);
		t = FindTag(pos + 2);
		Splay(t, Right[rt]);
		Left[Right[rt]] = nil;
		Push_up(Right[rt]);
		Push_up(rt);
	}

	void Replace(int pos, int v)
	{
		int t = FindTag(pos + 1);
		Splay(t, rt);
		if(val[rt] != v){ //值不同才需要更新
			val[rt] = v;
			Push_up(rt);
		}
	}

	void Query(int x, int y)
	{
		int t;
		t = FindTag(x);
		Splay(t, rt);
		t = FindTag(y + 2);
		Splay(t, Right[rt]);
		printf("%d\n", msum[Left[Right[rt]]]);
	}
};

SplayTree spl;

int main()
{
	//freopen("in.txt","r",stdin);
	int n, m, a, b;
	char ord[3];
	while(scanf("%d", &n) == 1)
	{
		spl.Init(n);
		scanf("%d", &m);
		while(m--)
		{
			scanf("%s", ord);
			if('I' == ord[0]){
				scanf("%d%d", &a, &b);
				spl.Insert(a, b);
			}
			else if('D' == ord[0]){
				scanf("%d", &a);
				spl.Delete(a);
			}
			else if('R' == ord[0]){
				scanf("%d%d", &a, &b);
				spl.Replace(a, b);
			}
			else{
				scanf("%d%d", &a, &b);
				spl.Query(a, b);
			}
		}
	}
	return 0;
}


指针型：

#include <cstdio>
#include <cstdlib>
#include <string>
#include <string.h>
#include <cmath>
#include <iostream>
#define MAX(x, y) ((x)>(y)?(x):(y))
const int MAXN = 100010;
using namespace std;
typedef int Type;

typedef struct TREE
{
	Type val;
    Type sum; //以该结点为根的树的元素和
    Type lsum; //以该结点为根的区间从左往右的最大连续和
    Type rsum; //以该结点为根的区间从右往左的最大连续和
    Type msum; //以该结点为根的区间的最大连续和
    TREE *fa, *l, *r;
    int sz; //以该结点为根的树的总结点数
}Tree;

struct SplayTree
{
	public:
	SplayTree()
	{
		rt = NULL;
		Size = 0;
		inf = 1000000000;
		memset(c, 0, sizeof(c));
	}

	~SplayTree()
	{
		FreeTree(rt);
	}

	void Push_up(Tree *T)
	{
		T->sz = (T->l ? T->l->sz : 0) + (T->r ? T->r->sz : 0) + 1;
		T->sum = T->val + (T->l ? T->l->sum : 0) +
			(T->r ? T->r->sum : 0);
		T->msum = T->lsum = T->rsum = T->val;
		Type t;
		if(T->l && T->r){
			T->lsum = MAX(T->l->lsum, T->l->sum + T->val + MAX(T->r->lsum, 0));
			T->rsum = MAX(T->r->rsum, T->r->sum + T->val + MAX(T->l->rsum, 0));
			T->msum = MAX(MAX(T->l->msum, T->r->msum), T->val + MAX(T->r->lsum, 0) + MAX(T->l->rsum, 0));
		}
		else if(T->l)
		{
			T->lsum = MAX(T->l->lsum, T->l->sum + T->val);
			T->rsum = MAX(T->l->rsum, 0) + T->val;
			T->msum = MAX(T->l->msum, T->rsum);
		}
		else if(T->r)
		{
			T->rsum = MAX(T->r->rsum, T->r->sum + T->val);
			T->lsum = MAX(T->r->lsum, 0) + T->val;
			T->msum = MAX(T->r->msum, T->lsum);
		}
	}

	void NewNode(Tree *pre, Tree *&T, Type v)
	{
		T = (Tree *)malloc(sizeof(Tree));
		T->sum = T->msum = T->lsum = T->rsum = T->val = v;
		T->sz = 1;
		T->fa = pre;
		T->l = T->r = NULL;
	}

	void MakeTree(Tree *&T, Tree *pre, int x, int y)
	{
		if(x > y) return;
		int mid = ((x + y)>>1);
		NewNode(pre, T, c[mid]);
		MakeTree(T->l, T, x, mid - 1);
		MakeTree(T->r, T, mid + 1, y);
		Push_up(T);
	}

	void Init(int n)
	{
		Size = n;
		NewNode(NULL, rt, -inf);
		NewNode(rt, rt->r, inf);
		rt->sz = 2;
		rt->r->fa = rt;
		int i;
		for(i = 0; i < n; i++)
			scanf("%d", c + i);
		MakeTree(rt->r->l, rt->r, 0, n - 1);
		Push_up(rt->r);
		Push_up(rt);
	}

	void R_rotate(Tree *x)
	{
		Tree *y = x->fa;
		Tree *z = y->fa;
		Tree *k = x->r;
		y->l = k;
		x->r = y;
		if(z){
			if(y == z->l) z->l = x;
			else z->r = x;
		}
		if(k) k->fa = y;
		y->fa = x;
		x->fa = z;
		Push_up(y);
	}

	void L_rotate(Tree *x)
	{
		Tree *y = x->fa;
		Tree *z = y->fa;
		Tree *k = x->l;
		y->r = k;
		x->l = y;
		if(z){
			if(y == z->r) z->r = x;
			else z->l = x;
		}
		if(k) k->fa = y;
		y->fa = x;
		x->fa = z;
		Push_up(y);
	}
	
	//寻找第x个数的结点
	Tree *FindTag(int x)
	{
		if(NULL == rt) return NULL;
		Tree *p;
		p = rt;
		Type sum = (p->l ? p->l->sz : 0) + 1;
		while(sum != x)
		{
			if(sum < x){
				p = p->r;
				x -= sum;
			}
			else p = p->l;
			if(NULL == p) break;
			sum = (p->l ? p->l->sz : 0) + 1;
		}
		return p;
	}

	void Splay(Tree *X, Tree *&T)
	{
		Tree *p, *end;
		end = T->fa;
		while(X->fa != end)
		{
			p = X->fa;
			if(end == p->fa){ //p是根结点
				if(X == p->l) R_rotate(X);
				else L_rotate(X);
				break;
			}
			//p不是根结点
			if(X == p->l){
				if(p == p->fa->l){
					R_rotate(p); //LL
					R_rotate(X); //LL
				}
				else{
					R_rotate(X); //RL
					L_rotate(X);
				}
			}
			else{
				if(p == p->fa->r){ //RR
					L_rotate(p);
					L_rotate(X);
				}
				else{ //LR
					L_rotate(X);
					R_rotate(X);
				}
			}
		}
		T = X;
		Push_up(T);
	}
		
	void Insert(int pos, Type v)
	{
		Tree *t = FindTag(pos);
		Splay(t, rt);
		t = FindTag(pos + 1);
		Splay(t, rt->r);
		NewNode(rt->r, rt->r->l, v);
		Push_up(rt->r);
		Size++;
	}

	void Delete(int pos)
	{
		if(NULL == rt) return;  
		Tree *t;
		t = FindTag(pos);
		Splay(t, rt);
		t = FindTag(pos + 2);
		Splay(t, rt->r);
		free(rt->r->l);
		rt->r->l = NULL;
		Push_up(rt->r);
		Push_up(rt);
		Size--;
	}

	void Replace(int pos, Type v)
	{
		Tree *t = FindTag(pos + 1);
		Splay(t, rt);
		if(rt->val != v){ //值不同才需要更新
			rt->val = v;
			Push_up(rt);
		}
	}

	void Query(int x, int y)
	{
		Tree *t;
		t = FindTag(x);
		Splay(t, rt);
		t = FindTag(y + 2);
		Splay(t, rt->r);
		printf("%d\n", rt->r->l->msum);
	}

	void FreeTree(Tree *T)
	{
		if(NULL == T) return;
		FreeTree(T->l);
		FreeTree(T->r);
		free(T);
	}
	private:
	Type c[MAXN], inf;
	Tree *rt;
	int Size;
};

SplayTree spl;

int main()
{
	//freopen("in.txt","r",stdin);
	int n, m;
	Type a, b;
	char ord[3];
	while(scanf("%d", &n) == 1)
	{
		spl.Init(n);
		scanf("%d", &m);
		while(m--)
		{
			scanf("%s", ord);
			if('I' == ord[0]){
				scanf("%d%d", &a, &b);
				spl.Insert(a, b);
			}
			else if('D' == ord[0]){
				scanf("%d", &a);
				spl.Delete(a);
			}
			else if('R' == ord[0]){
				scanf("%d%d", &a, &b);
				spl.Replace(a, b);
			}
			else{
				scanf("%d%d", &a, &b);
				spl.Query(a, b);
			}
		}
	}
	return 0;
}











午后红茶馆
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
erl-splay-tree：Erlang中的splay-tree实现
02-05
Erlang代码实现Splay Tree可能包括创建、插入、查找和删除等函数。这些函数通常会递归地遍历树，同时进行splaying。例如，`insert/3`函数接收一个键、值和当前树，找到插入位置并返回新的splayed树。`lookup/2`函数...
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现
05-04
一个简单的 AVL树、splay树、以及二叉搜索树的代码实现 也可在我的github仓库中下载： https://github.com/yunwei37/myClassNotes
SPOJ GSS6 4487. Can you answer these queries VI (SPLAY)
Jinx Jinx again
07-27 934
题目大意： 四个操作： I X Y 在x位置插入y D x 删除x位置的数 R x y 用y替换x位置上的数字 Q x y 求出[x,y]上的最大子序列的和。 思路分析： 对于动态维护序列肯定是splay了。 现在就考虑以下几个问题。 之前我们知道线段树处理连续的子序列的和是用区间合并的。那splay上怎么做。 考虑边界，如儿子为 0 或者是冗余节点怎么办？ 初始化的
SPOJ-GSS7 Can you answer these queries VII(树上区间最大和)
WZJRJ28
01-28 590
Given a tree with N (N |x_i| You have to apply Q (Q  1. 1 a b : answer the maximum contiguous sum (maybe empty,will always larger than or equal to 0 ) from the path a->b ( inclusive ). 2. 2 a b c :
Can you answer these queries VI 【SPOJ - GSS6】【Splay 最大子段和】
既然弱小，就只顾变强就是了
08-10 170
题目链接 这道题很容易看到，它是把操作给放到了Splay上面来做的，其实主要改变的就是一些pushup()里面的细节！左右子树没有节点的时候，可千万不要再去比较了！会WA死…… 呜呜呜，当时一直以为自己哪里没考虑到，后来一想，好像就是左右儿子节点不存在，而原来的左右最大是负数的时候，我们假如再去比较，就会得到一个实际上不存在的非负数。 然后，剩下的，就是基本的操作了，注意细节，Spla...
【SPOJ-GSS6】Can you answer these queries VI【Splay】
BraketBN
02-19 954
splay调起来好累... #include #include using namespace std; const int maxn = 200005, inf = 0x3f3f3f3f; int n, num[maxn]; inline int iread() { int f = 1, x = 0; char ch = getchar(); for(; ch '9'
SPOJ GSS6 Can you answer these queries VI ——Splay
weixin_34367845的博客
02-01 104
【题目分析】 增加了插入和删除。 直接用Splay维护就好辣！ 写了一个晚上，（码力不精），最后发现更新写挂了 【代码】 #include <cstdio> #include <cstring> #include <cmath> #include <cstdlib> #include <map&...
Can you answer these queries VIII 【SPOJ - GSS8】【Splay】
既然弱小，就只顾变强就是了
08-13 195
题目链接 题意：有N个（无符号整型）数，我们有如下的四种操作： (一)、插入一个数； (二)、删除某个位置上的数； (三)、把某个位置上的数换成一个数； (四)、查询这个区间上的，其中，0 ≤ K ≤ 10。 然后看到这个（2^32）很容易想到unsigned int刚好也是自然溢出的32位int。然后我们就可以利用unsigned int来避免取模了。 再后来，前三个问...
GSS6 - Can you answer these queries VI 题解
a_forever_dream的博客
08-23 268
题目传送门 题目大意： 带插入、删除、修改的区间最大子段和。 带插入那想都不用想就可以掏出SplaySplaySplay来乱搞了。 用SplaySplaySplay来维护区间最大子段和跟猫树差不多，如果不会猫树可以看GSS1。具体的实现也就是要考虑上自己，其他没什么区别。 之前TLE了半天，直到发现网上这位大佬的指点，replace操作需要先修改再SplaySplaySplay，不然会TLE。 就...
SPOJ GSS3 - Can you answer these queries III【线段树 or Splay】
niiick
04-24 151
splay
SPOJ GSS6 Can you answer these queries VI
yamiedie_
04-09 539
题意： 要求维护一个数列， 满足插入， 删除，修改和询问最大连续子段和的操作。。 思路： 用splay维护， 由于子段要求非空。。 所以push_up那里不能直接用空儿子的值。。 #include #include #include #include #include #include #include #include #include #include us
splay_tree:Rust的基于Splay树的集合（例如，地图，集合，堆）库
05-17
splay_tree splay_tree提供基于自上而下的splay树的数据结构，例如map，set和heap。 扩展树是一种自我调整的二进制搜索树，具有最近访问的元素可以快速再次访问的附加属性。 它在O（log n）摊销时间内执行基本操作，...
splay-tree：快速的splay-tree数据结构
02-05
它支持拆分，合并密钥更新将项目批量装入空树或非空树插入重复项或不重复项查找而不散开 运作方式平均最糟糕的情况空间上） 上） 搜索O（log n） 摊销O（log n） 插O（log n） 摊销O（log n） 删除O（log n） 摊销O...
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
基于python开发的居民区电动汽车TOPSIS有序充电仿真+源码解析+项目文档+仿真（毕业设计&课程设计&项目开发）
最新发布
08-06
基于python开发的居民区电动汽车TOPSIS有序充电仿真+源码解析+项目文档+仿真，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用，详情见md文档~ 项目简介： "Simulation.md" 为代码解析说明文档 "仿真过程.py" 为仿真过程代码 "cargo.txt" 为随机生成的电动汽车出行数据，格式为[离开时间，回来时间，是否出行，剩余电量百分比]，其中是否出行 1表示出行，0表示不出行 "cargo.py" 为生成电动汽车出行数据代码 "carimf.txt" 为电动汽车信息初始化数据，格式为[序号，电池容量，慢充时间，最大行驶里程，慢充每15分钟增加电量百分比] "price.txt" 为时间价格表，格式为[时间，时段，电价]，其中，时段1表示峰时，时段2表示谷时，时段3表示平时 "drawpic.py" 为绘图函数 "小区居民日常负荷数据.txt" 为通过蒙特卡洛方法生成的小区居民日常负荷数据，格式为[时间，负荷]
【流程管理】LTC流程介绍.pptx
08-06
【流程管理】LTC流程介绍.pptx
libmavsdk-server.so-debug-202408062018-wk-proto-ok
08-06
libmavsdk_server.so_debug_202408062018_wk_proto_ok
信息安全lsClssify-mas笔记
08-06
信息安全lsClssify-mas笔记
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值