[NOI2005]维修数列

最新推荐文章于 2019-09-10 20:14:22 发布
最新推荐文章于 2019-09-10 20:14:22 发布
阅读量559 收藏
点赞数
分类专栏： BZOJ 文章标签： Splay+Lazy tag
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sddyzjh/article/details/41977161
版权

立flag以后滚去复习会考

然后会考一坨翔

然后边颓边写,边颓边改......然后就过了

然后发现跑的还挺快

顺便YM在THU虐场的faebdc

----------------------------------------------------------

Splay对于区间的操作就是用子树来表示区间

然后一个很好的性质是无论怎么转小的总是在左边

于是用相对位置来表示在数组中的下标

最大子段和比较蛋疼

要考虑好多情况

Reverse的时候一定不要忘记swap(LMax, RMax)!!!!!!!!!!

建树用了递归(我很弱)

如果还有问题或者觉得代码风格鬼畜请在下面留言

说实话数据结构题的题解真的不必要......

被坑的地方还是要发出来的

还有GET-SUM的区间长度可能是0

Code:

#include <cstdio>
#include <queue>
using namespace std;
queue<int> Q;
struct Splay_Tree
{
	Splay_Tree *F, *Ls, *Rs;
	int Size, Reverse, All, Sum, Key, LMax, RMax, Max;
	inline void Clear()
	{
		Size = Reverse = Sum = Key = LMax = RMax = Max = 0;
		F = Ls = Rs = NULL;
		All = 23333;
	}
	inline void Init(int x)
	{
		Key = Sum = LMax = RMax = Max = x;
		Size = 1;
	}
	inline void Update()
	{
		Pushdown();
//		puts("");
//		Debug();
		Sum = Key, Size = 1;
		Max = LMax = RMax = Key;
		if (Ls && Rs)
		{
			Ls->Pushdown();
			Rs->Pushdown();
			Size += Ls->Size, Sum += Ls->Sum;
			Size += Rs->Size, Sum += Rs->Sum;
			LMax = max(max(max(Ls->LMax, Ls->Sum+Key), Ls->Sum+Key+Rs->LMax), Ls->Sum+Key+Rs->Sum);
			RMax = max(max(max(Rs->RMax, Rs->Sum+Key), Rs->Sum+Key+Ls->RMax), Rs->Sum+Key+Ls->Sum);
			Max = max(max(max(max(max(max(max(Key, Ls->RMax+Key+Rs->LMax), Ls->RMax+Key), Ls->Max), Rs->Max), Key+Rs->LMax), LMax), RMax);
			return;
		}
		if (Ls)
		{
			Ls->Pushdown();
			Size += Ls->Size, Sum += Ls->Sum;
			LMax = max(Ls->LMax, Ls->Sum+Key);
			RMax = max(max(Ls->RMax+Key, Ls->Sum+Key), Key);
			Max = max(max(Ls->Max, RMax), LMax);
			return;
		}
		if (Rs)
		{
			Rs->Pushdown();
			Size += Rs->Size, Sum += Rs->Sum;
			RMax = max(Rs->RMax, Rs->Sum+Key);
			LMax = max(max(Rs->LMax+Key, Rs->Sum+Key), Key);
			Max = max(max(Rs->Max, RMax), LMax);
			return;
		}
	}
	inline void Zig()
	{
		Pushdown();
		if (F)
		{
			Splay_Tree *p = F;
			p->Ls = Rs;
			if (Rs)Rs->F = p;
			Rs = p;
			F = p->F;
			p->F = this;
			p->Update();
			Update();
			if (F)
			{
				if (p == F->Ls)
					F->Ls = this;
				else
					F->Rs = this;
				F->Update();
			}
		}
		else
			puts("´óɵ±Æ");
	}
	inline void Zag()
	{
		Pushdown();
		if (F)
		{
			Splay_Tree *p = F;
			p->Rs = Ls;
			if (Ls)Ls->F = p;
			Ls = p;
			F = p->F;
			p->F = this;
			p->Update();
			Update();
			if (F)
			{
				if (p == F->Ls)
					F->Ls = this;
				else
					F->Rs = this;
				F->Update();
			}
		}
		else
			puts("´óɵ±Æ");
	}
	inline void Pushdown()
	{
		if (Reverse)
		{
			Reverse = 0;
			swap(Ls, Rs);
			swap(LMax, RMax);
			if (Ls)Ls->Reverse ^= 1;
			if (Rs)Rs->Reverse ^= 1;
		}
		if (All != 23333)
		{
			Key = All;
			Sum = Size * All;
			if (All > 0)
				LMax = RMax = Max = Sum;
			else
				LMax = RMax = Max = All;
			if (Ls)Ls->All = All;
			if (Rs)Rs->All = All;
			All = 23333;
		}
	}
	inline void Debug()
	{
		Pushdown();
		if (Ls)Ls->Debug();
		printf("%d ", Key);
		if (Rs)Rs->Debug();
	}
}*Root, T[500001];
int n, m, Number[200001];
inline Splay_Tree *New(int x)
{
	if (Q.empty())
	{
		puts("´óɵ±Æ");
		return NULL;
	}
	Splay_Tree *p = &T[Q.front()];
	Q.pop();
	p->Clear();
	p->Init(x);
	return p;
}
inline void Splay(Splay_Tree *s, Splay_Tree *t)
{
	if (!s || s == t)return;
	if (t == NULL)Root = s;
	while (s->F != t)
	{
		s->Pushdown();
		if (s->F->F == t)
		{
			if (s == s->F->Ls)
				s->Zig();
			else
				s->Zag();
		}
		else
		{
			if (s->F->F->Ls == s->F)
			{
				if (s->F->Ls == s)
					s->F->Zig(), s->Zig();
				else
					s->Zag(), s->Zig();
			}
			else
			{
				if (s->F->Ls == s)
					s->Zig(), s->Zag();
				else
					s->F->Zag(), s->Zag();
			}
		}
	}
}
inline Splay_Tree *Select(Splay_Tree *p, int x)
{
	if (!p)return p;
	p->Pushdown();
	int now(1);
	if (p->Ls)now += p->Ls->Size;
	if (x == now)
		return p;
	if (x > now)
		return Select(p->Rs, x-now);
	return Select(p->Ls, x);
}
inline Splay_Tree *Build(int l, int r, int *a)
{
	if (l > r)return 0;
	int mid = (l + r) >> 1;
	Splay_Tree *p = New(a[mid]);
	p->Ls = Build(l, mid-1, a), p->Rs = Build(mid+1, r, a);
	if (p->Ls)p->Ls->F = p;
	if (p->Rs)p->Rs->F = p;
	p->Update();
	return p; 
}
inline void Insert(int x, int len, int *a)
{
	n += len;
	if (!Root)
	{
		Root = Build(1, len, a);
		return;
	}
	if (!x)
	{
		Splay(Select(Root, 1), Root->F);
		Root->Ls = Build(1, len, a);
		Root->Update();
		Root->Ls->F = Root;
		return;
	}
	if (x == n-len)
	{
		Splay(Select(Root, x), Root->F);
		Root->Rs = Build(1, len, a);
		Root->Update();
		Root->Rs->F = Root;
		return;
	}
	Splay(Select(Root, x), Root->F), Splay(Select(Root, x+1), Root);
	Root->Rs->Ls = Build(1, len, a);
	Root->Rs->Ls->F = Root->Rs;
	Root->Pushdown();
	Root->Rs->Pushdown();
	//Splay(Root->Rs->Ls, Root->F);
	Root->Rs->Update();
	Root->Update();
}
inline void Delete(Splay_Tree *s)
{
	if (s->Ls)
		Delete(s->Ls), s->Ls = NULL;
	if (s->Rs)
		Delete(s->Rs), s->Rs = NULL;
	Q.push(s-&T[0]);
	n--;
}
inline void Delete(int l, int r)
{
	if (l == 1 && r == n)
	{
		Delete(Root);
		Root = NULL;
		return;
	}
	if (l == 1)
	{
		Splay(Select(Root, r+1), Root->F);
		Delete(Root->Ls);
		Root->Ls = NULL;
		Root->Update();
		return;
	}
	if (r == n)
	{
		Splay(Select(Root, l-1), Root->F);
		Delete(Root->Rs);
		Root->Rs = NULL;
		Root->Update();
		return;
	}
	Splay(Select(Root, l-1), Root->F);
	Splay(Select(Root, r+1), Root);
	Delete(Root->Rs->Ls);
	Root->Rs->Ls = NULL;
	Root->Rs->Update();
	Root->Update();
}
inline void MakeSame(int l, int r, int x)
{
	if (l == 1 && r == n)
	{
		Root->All = x;
		return;
	}
	else
	if (l == 1)
	{
		Splay(Select(Root, r+1), Root->F);
		Root->Ls->All = x;
		Splay(Root->Ls, Root->F);
		return;
	}
	else
	if (r == n)
	{
		Splay(Select(Root, l-1), Root->F);
		Root->Rs->All = x;
		Splay(Root->Rs, Root->F);
		return;
	}
	Splay(Select(Root, l-1), Root->F);
	Splay(Select(Root, r+1), Root);
	Root->Rs->Ls->All = x;
	Splay(Root->Rs->Ls, Root->F);
}
inline void Reverse(int l, int r)
{
	if (l == 1 && r == n)
	{
		Root->Reverse ^= 1;
		return;
	}
	else
	if (l == 1)
	{
		Splay(Select(Root, r+1), Root->F);
		Root->Ls->Reverse ^= 1;
		Splay(Root->Ls, Root->F);
		return;
	}
	else
	if (r == n)
	{
		Splay(Select(Root, l-1), Root->F);
		Root->Rs->Reverse ^= 1;
		Splay(Root->Rs, Root->F);
		return;
	}
	Splay(Select(Root, l-1), Root->F);
	Splay(Select(Root, r+1), Root);
	Root->Rs->Ls->Reverse ^= 1;
	Splay(Root->Rs->Ls, Root->F);
}
inline int GetSum(int l, int r)
{
	if (l == 1 && r == n)
		return Root->Sum;
	else
	if (l == 1)
	{
		Splay(Select(Root, r+1), Root->F);
		return Root->Ls->Sum;
	}
	else
	if (r == n)
	{
		Splay(Select(Root, l-1), Root->F);
		return Root->Rs->Sum;
	}
	Splay(Select(Root, l-1), Root->F);
	Splay(Select(Root, r+1), Root);
	return Root->Rs->Ls->Sum;
}
inline int MaxSum()
{
	Root->Pushdown();
	return Root->Max;
}
inline void Debug(){if (Root)Root->Debug(), puts("");}
char c, ch[100];
inline void read(int &x)
{
	int opt(1);
	for (c = getchar();c > '9' || c < '0';c = getchar())
		if (c == '-')opt = -1;
	for (x = 0;c >= '0' && c <= '9';c = getchar())
		x = (x << 3) + (x << 1) + c - '0';
	x *= opt;
}
int main()
{
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);
	int i, j, l, r, mid, len, pos;
	for (i = 0;i < 500001; ++i)Q.push(i);
	read(n), read(m);
	for (i = 1;i <= n;read(Number[i]), ++i);
	Root = Build(1, n, Number);
	for (c = getchar();m;m--, c = getchar())
	{
//		Debug();
		switch (c)
		{
			case ('I') : 
			{
				read(pos), read(len);
				for (i = 1;i <= len;read(Number[i]), ++i);
				Insert(pos, len, Number);
//				printf("INSERT %d %d\n", pos, len);
				break;
			}
			case ('D') : 
			{
				read(pos), read(len);
				Delete(pos, pos+len-1);
//				printf("DELETE %d %d\n", pos, len);
				break;
			}
			case ('M') : 
			{
				c = getchar();
				if (getchar() == 'K')
				{
					for (c = getchar();c != '-';c = getchar());
					read(pos), read(len), read(mid);
					MakeSame(pos, pos+len-1, mid);
//					printf("MAKE-SAME %d %d %d\n", pos, len, mid);
				}
				else
				{
					for (c = getchar();c != '\n';c = getchar());
					printf("%d\n", MaxSum());
				}
				break;
			}
			case ('R') : 
			{
				read(pos), read(len);
				Reverse(pos, pos+len-1);
//				printf("REVERSE %d %d\n", pos, len);
				break;
			}
			case ('G') : 
			{
				for (c = getchar();c != '-';c = getchar());
				read(pos), read(len);
				if (!len)
				{
					puts("0");
					continue;
				}
//				printf("GET-SUM %d %d ", pos, len);
				printf("%d\n", GetSum(pos, pos+len-1));
				break;
			}
		}
	}
	return 0;
}


sddyzjh
关注
专栏目录
NOI2005 维修数列
weixin_30379973的博客
08-21 105
昨天A掉的这题，然后伸展树还有最后一题没敲。很BT的一题，但是感觉学习伸展树不做这道题不算真正学过吧。 这道题多了一个操作，求子序列和的最大值。这个东西怎么维护？其实和学习线段树的时候很经典的那个Hotel基本一样，维护一个最左端的和的最大值，维护一个最右端和的最大值，维护一个最大值，维护一个区间和。然后区间合并的操作就好写了，不过写的时候细节的地方要特别注意一下，例如，没有左节点的情况。...
【NOI 2005】 维修数列
03-09 117
【题目链接】 点击打开链接 【算法】 本题所运用的也是Splay的区间操作，但是实现较为困难 INSERT操作 将pos splay至根节点，pos+1 splay至根节点的右节点，然后对根节点的右节点的左节点建树即可 DELETE操作 ...
noi 2005维修数列
diyan5166的博客
08-27 248
OI生涯中最想过的一题=v= splay加上各种各样的操作，样例又不敢拿来调了。。。 感觉指针写splay好难调，所以以后写splay都用数组吧（其实是因为黄大神也用数组orz） 好像是2小时敲完。。debug了2天TAT一开始把操作6和某提混了。。。 然后搞来搞去才发现读入有个毛病0A0 再然后又发现一直以来自己的pushdown和别人是不一样的。。（那些题我居然过了。。...
[BZOJ1500]NOI2005 维修数列|splay
Tag_king的专栏
04-18 1912
这题号称是noi出过最变态的数据结构题，，感觉还差不多嘛。。一开始我一直在纠结splay上的节点一点要有一个key值的啊，要是以这个数在序列中的位置作为key值的话又要插入又要删除肯定弄不了。。然后想了很久突然顿悟。。貌似我给一个初始顺序以后是不用访问key的&&找第k位的数只要写一个findkth就行了嘛。。（当时太弱） 然后我就一口气写了下来。。 对每个节点维护size，sum，maxsu
NOI2005维修数列
weixin_30294021的博客
01-13 70
学习hzwer的代码。 http://hzwer.com/2841.html 这是一道经典的splay模板题 入门建议阅读《伸展树的基本操作与应用》，以及手画练习 以下模板是结合前人经验，经多次修改后的结果 c分别是结点左右儿子，fa是结点父亲 size是子树大小，sum是子树权值和，v是结点权值，mx是当前子树的最大子串和 lx是一个子树以最左端为起点向右延伸的最大子串和，rx类似...
NOI 2005 维修数列
Mr_Xujh的博客
05-01 476
NOI 2005 维修数列 典型的伸展树模板题 参考 http://www.cnblogs.com/kuangbin/archive/2013/08/28/3287822.html #include #include #include #include #include using namespace std; #define Key_value ch[ch[root][1]][0
NOI2005 维修数列 Splay
rgnoH的博客
11-28 265
题目大意： 给出一个初始序列，要求实现下面的操作： 1.在当前序列的某个位置插入连续的若干个元素； 2.删除当前序列的某一段元素； 3.将当前序列中某一段元素全部修改为某个值； 4.翻转某个区间； 5.求当前序列某一段元素的总和； 6.求出当前序列中连续和的最大值。
bzoj1500 noi2005 维修数列
C_K_Y_的博客
01-14 420
1500: [NOI2005]维修数列Time Limit: 10 Sec  Memory Limit: 64 MBSubmit: 15855  Solved: 5269[Submit][Status][Discuss]DescriptionInput输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。...
NOI2005维修数列（splay）
weixin_30455661的博客
09-07 70
题目描述： Description 请写一个程序，要求维护一个数列，支持以下 6 种操作： 请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格 Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。以下M行，每行一条命令，格...
NOI2005维护数列原题
02-17
维护数列 【问题描述】 请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 操作编号 输入文件中的格式 说明 1. 插入 INSERT_posi_tot_c1_c2_.....
BZOJ1500: [NOI2005]维修数列（洛谷P2042）
forezxl的博客
12-09 358
Splay
NOI2005 维护数列
Holylight_Knight
10-10 643
NOI2005 维护数列tags :【Splay】,【BZOJ1500】,【洛谷2042】在线评测地址：洛谷，大视野题目描述1500: [NOI2005]维修数列Time Limit: 10 Sec Memory Limit: 64 MBDescriptionInput输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，
BZOJ 1500 [NOI2005]维修数列 （无旋treap良心题解）
shadiao.的博客
09-10 276
题目传送门 上面链接沉了幸亏洛谷还有这道题 无旋treap解题的原理： 1.无旋treap可以在维护平衡的同时保持中序遍历不变（treap也可以，应该都可以），因此我们用下标代表插入二叉树的值，那么我们可以按照中序遍历获得原来的数组。 2.无旋treap的分裂操作可以分裂出包含前k个节点的树和剩下元素的树，就相当于可以把数组切开。 你可以切取想要的区间进行操作，操作完再merge回去即可...
【BZOJ】1500: [NOI2005]维修数列-splay
远行客
12-05 150
splay模板
[SDOI2010]猪国杀
emmmm
11-27 1444
Au爷faebdc:"神犇来做猪国杀吧,我自己做太蛋疼了" 蒟蒻:"好吧" Au爷faebdc“我过了” 蒟蒻:"......" Au爷faebdc:"我rank1了" 蒟蒻:"......" 两天后 蒟蒻:"我过了" Au爷faebdc:"......" --------------------------------------------------------------
bzoj1461字符串的匹配
emmmm
01-19 1179
KMP学了3遍了...... 这题就是kmp匹配过程中用树状数组维护每个数字出现的次数,快速查询在前面比自己小的和等于自己的来判断是否能向后匹配 原题USACO 2005 December cpattern Code: #include #include #include using namespace std; #define lowbit(x) (x & -x) #define
[SCOI2010]序列操作
emmmm
10-11 797
傻逼线段树水题……调了
LCT系列
emmmm
12-23 795
#1:[HNOI2010]弹飞绵羊 这道题是YM了Seter的模板以后过的 后来YM了wangxz神犇的姿势 题意:换父亲,询问点到根路径上的节点数 新技能:用fread刷rank Code: #include using namespace std; #define N 200001 struct Splay_Tree { Splay_Tree *F, *Ls, *Rs;
[SDOI2010]古代猪文
emmmm
10-22 669
写的时候各种傻逼错误不能更逗 10年就考了这种题
NOI Linux安装步骤详解
"NOI Linux是专为 NOI (全国青少年信息学奥林匹克竞赛) 设计的一款Linux发行版，旨在提供一个稳定且适合编程竞赛的环境。本文提供了NOI Linux的简要安装步骤，帮助参赛者和相关人员顺利安装操作系统。" 在安装NOI ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值