P2042 [NOI2005]维护数列（Splay 维护序列区间操作，Splay下推标记）

最新推荐文章于 2024-07-11 22:11:10 发布
最新推荐文章于 2024-07-11 22:11:10 发布
阅读量258 收藏
点赞数
文章标签： Splay维护序列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41997978/article/details/104180777
版权

在这里插入图片描述

Splay维护序列练习题，比较麻烦的是标记的下推 和 pushup 操作，两个哨兵节点的初始值应赋为无穷小避免影响操作6的答案。区间更新操作时要pushup 到 root，否则 更新点到 root 维护的信息可能有误

建树： 直接对数组用类似线段树的方法建树，由于要建立哨兵节点，哨兵节点的权值应赋为无穷小。

操作1： 找到起始位置 x，将 x 伸展到 root，并找到 x 的后继 y，y 一定没有左儿子，将要插入的节点依次插入到 后继 y 的左儿子，下一个插入点插入到上一个插入点的右儿子，最后将最后一个点伸展到 root，就完成了，常数也不大，注意向下找后继时要边找边pushdown

操作2： 删除区间 [ l , r ] [l,r] [l,r]，将 l − 1 l - 1 l−1 伸展到 root， r + 1伸展到 l − 1 l - 1 l−1 的子节点，直接将 r + 1 r + 1 r+1 的左儿子整颗子树删掉即可。由于最多插入 4 ∗ 1 0 6 4*10^6 4∗106 个节点，会爆空间，删除时将删除的点的编号回收，申请节点时优先使用回收的编号。

操作3： 伸展操作同操作2 ，对 r + 1 r + 1 r+1 的左儿子更新并打一个标记，同时 pushup(r + 1) ，pushup(root)，这里如果不pushup，后面 r + 1 r + 1 r+1 和 r o o t root root 可能就无法根据子节点权值变化维护正确的信息

操作4： 伸展操作同操作2，首先判断有没有操作3的标记，如果有操作3的标记，整颗子树都是同样的权值，没必要翻转。否则先 翻转 r + 1 r + 1 r+1 的左儿子的左右子树，并打一个标记，pushup(r + 1)，pushup(root)，理由同操作3

操作5： 考虑对每个结点维护子树和，询问时伸展操作同操作2，答案就是 ch[r + 1][0] 的子树和

操作6： 同样考虑维护子树的信息，用类似线段树维护最大子段和的方法，每个结点维护 l v , r v , m v lv,rv,mv lv,rv,mv 表示以其为根，子树区间 的左连续最大子段和，右连续最大子段和，以及整段区间的最大子段和，转移同线段树的转移，答案就是根节点的 m v mv mv，但要注意哨兵结点的权值必须赋为无穷小

卡常，要开O2才能过

#include<bits/stdc++.h>
using namespace std;
const int maxn = 4e6 + 10;
typedef long long ll;
const ll inf = 1e15;
int n,m;
ll a[maxn];
vector<int> tmp;
inline int read(){
    int x=0,f=1;char ch=getchar();
    while (ch<'0' || ch>'9'){if (ch=='-')f=-1;ch=getchar();}
    while ('0'<=ch && ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    return x*f;
}
struct Splay_tree {
	int ch[maxn][2];		//ch[u][0] 表示 左二子，ch[u][1] 表示右儿子
	int f[maxn];			//当前节点的父节点 
	int sz[maxn]; 			//当前节点的子树的节点个数
	ll val[maxn];			//当前节点的权值
	int cnt[maxn];			//当前节点所表示的值的个数
	int tag[maxn],add[maxn];
	ll sum[maxn],lv[maxn],rv[maxn],mv[maxn]; 
	int root;				//根节点
	int tot;				//总节点的个数 
	queue<int> q;
	inline bool get(int x) {
    	return ch[f[x]][1] == x;
	}
	inline void init() {
		root = tot = 0;
		f[0] = ch[0][0] = ch[0][1] = sz[0] = val[0] = cnt[0] = 0;
		sum[0] = lv[0] = rv[0] = mv[0] = tag[0] = add[0] = 0;
	}
	inline void pushup(int rt) {							//维护 rt 的 sz
		if(rt) {
			sz[rt] = 1;
			lv[rt] = mv[rt] = rv[rt] = sum[rt] = val[rt];
			if(ch[rt][1]) {
				mv[rt] = max(mv[rt],mv[ch[rt][1]]);
				mv[rt] = max(mv[rt],rv[rt] + lv[ch[rt][1]]);
				lv[rt] = max(lv[rt],lv[ch[rt][1]] + sum[rt]);
				rv[rt] = max(rv[ch[rt][1]],sum[ch[rt][1]] + rv[rt]);
				sz[rt] += sz[ch[rt][1]];
				sum[rt] += sum[ch[rt][1]];
			}
			if(ch[rt][0]) {
				mv[rt] = max(mv[rt],mv[ch[rt][0]]);
				mv[rt] = max(mv[rt],rv[ch[rt][0]] + lv[rt]);
				lv[rt] = max(lv[ch[rt][0]],sum[ch[rt][0]] + lv[rt]);
				rv[rt] = max(rv[rt],sum[rt] + rv[ch[rt][0]]);
				sz[rt] += sz[ch[rt][0]];
				sum[rt] += sum[ch[rt][0]];
			}
		}
	}
	inline void pushdown(int x) {					//翻转 rt 的两棵子树
	    int l=ch[x][0],r=ch[x][1];
	    if (add[x]){
	        tag[x]=add[x]=0;//我们有了一个统一修改的标记，再翻转就没有什么意义了
	        if (l)add[l]=1,val[l]=val[x],sum[l]=1ll*val[x]*sz[l];
	        if (r)add[r]=1,val[r]=val[x],sum[r]=1ll*val[x]*sz[r];
	        if (val[x] >= 0) {
	        	if (l)lv[l]=rv[l]=mv[l]=sum[l];
	        	if (r)lv[r]=rv[r]=mv[r]=sum[r];
	        } else {
	        	if (l)lv[l]=rv[l]=mv[l]=val[x];
	        	if (r)lv[r]=rv[r]=mv[r]=val[x];
			}
	    }
	    if (tag[x]){
	        tag[x]=0;
	        if(l) swap(lv[l],rv[l]),swap(ch[l][0],ch[l][1]),tag[l]^=1;
			if(r) swap(lv[r],rv[r]),swap(ch[r][0],ch[r][1]),tag[r]^=1;
	        //注意，在翻转操作中，前后缀的最长上升子序列都反过来了，很容易错
	    }
	}
	inline void newnode(int rt,ll v,int fa) {		//新建节点 
		f[rt] = fa;
		cnt[rt] = sz[rt] = 1;
		add[rt] = tag[rt] = ch[rt][0] = ch[rt][1] = 0;
		val[rt] = sum[rt] = lv[rt] = rv[rt] = mv[rt] = v;
	}
	inline void delnode(int &rt) {
		if(ch[rt][0]) delnode(ch[rt][0]);
		if(ch[rt][1]) delnode(ch[rt][1]); 
		f[rt] = sz[rt] = val[rt] = 0;
		sum[rt] = add[rt] = tag[rt] = ch[rt][0] = ch[rt][1] = 0;
		lv[rt] = rv[rt] = mv[rt] = 0;
		q.push(rt);
		rt = 0;
	}
	inline void build(int &rt,int l,int r,int fa) {
		if (l > r) return ;
		int mid = l + r >> 1;
		rt = ++tot; newnode(rt,a[mid],fa);
		build(ch[rt][0],l,mid - 1,rt);
		build(ch[rt][1],mid + 1,r,rt);
		pushup(rt);
	}
	inline void rotate(int x) {							//旋转操作，根据 x 在 f[x] 的哪一侧进行左旋和右旋 
	    int old = f[x], oldf = f[old];
	    pushdown(old); pushdown(x); 				//如果先推 x,旋完之后 x 仍可能带有标记，这样旋 x 一定没有标记 
	    int whichx = get(x);
	    ch[old][whichx] = ch[x][whichx ^ 1];
	    f[ch[old][whichx]] = old;
	    ch[x][whichx ^ 1] = old; f[old] = x;
	    f[x] = oldf;
	    if(oldf) ch[oldf][ch[oldf][1] == old] = x;
	    pushup(old); pushup(x);						//不要忘记更新
	}
	inline void splay(int x,int goal) {					//将 x 旋到 goal节点  下面
    	for (int fa = f[x]; fa != goal; rotate(x), fa = f[x])	//再把x翻上来
        	if (f[fa] != goal)						//如果fa非根，且x 和 fa是同一侧，那么先翻转fa，否则先翻转x 
            	rotate((get(x)==get(fa))?fa:x);
        if (goal == 0)
			root = x;
	}
	inline int findx(int x) {								//查询第x个数的节点 
		int now = root;
		if (!now)  return 0;
		while(1) {
			pushdown(now);							//每次下推标记 
			if(ch[now][0] && sz[ch[now][0]] >= x) {
				now = ch[now][0];
			} else {
				int sum = cnt[now] + (ch[now][0] ? sz[ch[now][0]] : 0);
				if (x <= sum) return now;
				x -= sum, now = ch[now][1];
			}
		}
		return now;
	}
    inline void del(int l,int r) {					//仅针对 P2042 [NOI2005]维护数列的删除操作 ，删除[l,r]之间的点 
    	int x = findx(l - 1), y = findx(r + 1);
    	splay(x,0);
    	splay(y,x);
    	delnode(ch[ch[root][1]][0]);
    	pushup(ch[root][1]);
    	pushup(root);
	}
	inline void insert(int x) {				//在 第 x 个数之后插入一个值 v 
		int fx = findx(x);
		splay(fx,0);
		int k = ch[root][1];
		pushdown(k);
		while (ch[k][0]) {
			k = ch[k][0];
			pushdown(k);
		}
		int p = root;
		for (int i = 0; i < tmp.size(); i++) {
			if(!q.empty()) p = q.front(), q.pop();
			else p = ++tot;
			newnode(p,tmp[i],k);
			if (i == 0) {
				ch[k][0] = p;
				k = ch[k][0];	
			} else {
				ch[k][1] = p;
				k = ch[k][1];
			}
		}
		tmp.clear();
		splay(k,0);
	}
	inline void update(int l,int r,int c) {		//将 l,r区间内的值修改为 c 
		int x = findx(l - 1), y = findx(r + 1);
    	splay(x,0);
    	splay(y,x);
    	int p = ch[ch[root][1]][0];
    	add[p] = 1; val[p] = c;
    	sum[p] = 1ll * sz[p] * c;
    	if(c >= 0) lv[p] = rv[p] = mv[p] = sum[p];
    	else lv[p] = rv[p] = mv[p] = c;
    	pushup(y); pushup(f[y]);
	}
	inline void change(int l,int r) {
		int x = findx(l - 1), y = findx(r + 1);
    	splay(x,0);
    	splay(y,x);
    	int p = ch[ch[root][1]][0];
    	if(!add[p]) {
	    	swap(ch[p][0],ch[p][1]);
	    	swap(lv[p],rv[p]);
	    	tag[p] ^= 1;
	    	pushup(y); pushup(x);
	    }
	}
	ll ask_sum(int l,int r) {
		int x = findx(l - 1), y = findx(r + 1);
    	splay(x,0);
    	splay(y,x);
    	return sum[ch[ch[root][1]][0]];
	}
	ll max_sum() {
		return mv[root];
	}
}tree;
char s[maxn];
int main() {
	n = read(); m = read();
	for (int i = 2; i <= n + 1; i++)
		a[i] = read();
	a[1] = a[n + 2] = -inf;
	tree.init();
	tree.build(tree.root,1,n + 2,0);
	int cnt = 0;
	while(m--) {
		cnt++;
		scanf("%s",s);
		if(strcmp(s,"INSERT") == 0) {
			int x,y,z; x = read(); y = read();
			x++;
			for (int i = 1; i <= y; i++) {
				z = read();
				tmp.push_back(z);
			}
			tree.insert(x);
		} else if(strcmp(s,"GET-SUM") == 0) {
			int x,y; x = read(); y = read();
			int l = x + 1, r = x + y;
			printf("%lld\n",tree.ask_sum(l,r));
		} else if(strcmp(s,"MAX-SUM") == 0) {
			printf("%lld\n",tree.max_sum());
		} else if(strcmp(s,"DELETE") == 0) {
			int x,y; x = read(); y = read();
			int l = x + 1, r = x + y;
			tree.del(l,r);
		} else if(strcmp(s,"MAKE-SAME") == 0) {
			int x,y,v; x = read(); y = read(); v = read();
			int l = x + 1, r = x + y;
			tree.update(l,r,v);
		} else if(strcmp(s,"REVERSE") == 0) {
			int x,y; x = read(); y = read();
			int l = x + 1, r = x + y;
			tree.change(l,r);
		}
	}
	return 0;
}
ACM败犬
关注
NOI2005 维护数列
Holylight_Knight
10-10 666
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个数字，
[NOI2005] 维护数列（Splay）
hipamp的博客
10-11 397
题意 要求维护一个数列，支持以下操作： 其中，插入总数字个数小于 4e64e64e6，每个数在 [−1000,1000][-1000,1000][−1000,1000] 范围，保证每次操作合法。 分析 这道题是一道 SplaySplaySplay 码农题，细节颇多，让我们一个一个操作分析。 插入操作 我们可以先对要插入的这 tottottot 个数建树，得到树根 trttrttrt，再将 trttrttrt 插入原序列。 删除操作 就是普通的删除，将 r+1r+1r+1 旋到根，将 l−1l-1l−1
【平衡树】【NOI 2005】维护数列
morestep的专栏
07-27 988
339. [NOI2005] 维护数列★★★★☆ 输入文件：seq2005.in 输出文件：seq2005.out 简单对比 时间限制：3 s 内存限制：256 MB 【问题描述】请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 【输入格式】输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数
P2042 [NOI2005]维护数列
dianshu0741的博客
09-25 101
毒瘤模板题！！！！ 这道题看到什么维护序列的，肯定就是用数据结构的。 这个东西叫你做下面的事情： 首先确定用什么数据结构。 看到翻转，二话不说就用splay。 第一个操作：在第posi位后加入tot个数字。我们就把这一段数字建出一个子splay。用类似线段树的建树方式解决掉，比一个一个加入的建树方式快，常数小。然后split出来中间的位置，暴力连接，pushup即可。 第二个操作：在第...
洛谷 P2042 【[NOI2005]维护数列】
dengpailuo0807的博客
03-15 158
一直在想要做这道题，但是被那个硕大的Splay标签压垮了 好了，切入正题 这道题应该是我第二次用splay来维护区间问题 我还是太菜了QAQ 其实思路也很简单，就是以每一个位置的下标来进行维护，然后其实就是跟权值树是一模一样的了 然后再具体说一下 为了保证效率，像线段树和文艺平衡树一样，我们可以维护一个\({lazytag}\),然后在需要向下查询时再向下查询就行 然后我们考虑两种标记...
[NOI2005]维护数列——Splay
weixin_30852419的博客
07-22 87
题面 　　洛谷P2042 解析 　　　　这道题集齐了大部分Splay的经典操作，上课时wys老师讲了一下，这个题还是很值得一做的 　　基操： 　　　　Splay上的所有区间操作都需要提取区间，如果要提取一个[l, r]的区间，只需要把l-1的点转到根，再把r+1的点转到根的右儿子，那么根的右儿子的左儿子的整颗子树就是我们要提取的区间 　　操作1：插入 　　　　这个题的插入并非插入一个...
BZOJ1500: [NOI2005]维修数列（洛谷P2042）
forezxl的博客
12-09 386
Splay
splay伸展树 指针型 平衡树基本操作 序列维护 详细讲解+总结
anantheparty的博客
12-21 3555
转载请保留本博客源地址：http://blog.csdn.net/u011327397/article/details/53783700 本来是要去学lct，然后看到要用splay我又不会，就开始看splay了，然后发现splay艹起来特别爽，但是序列操作网上没看到有详讲的，理解的时候很多奇怪的问题（无限RE）再加上指针调试复杂度高，花了很多时间，就觉得来写一个讲解吧。
【NOI2005】维护数列
WorldWide_D的博客
05-30 1524
Description请写一个程序，要求维护一个数列，支持以下6种操作：（请注意，格式栏中的下划线‘ _ ’表示实际输入文件中的空格） 1. 插入 INSERT_posi_tot_c1_c2_…_ctot 在当前数列的第posi个数字后插入tot个数字：c1, c2, …, ctot；若在数列首插入，则posi为0 2. 删除 DELETE_posi_tot 从当前数列的第posi个数字开始连续
[平衡树刷题] 模板 P2042 [NOI2005] 维护数列
HeartFireY的博客
11-15 493
对于插入区间，分裂后硬插即可，但注意不要裂成俩之后再调用原始的插入，因为裂开之后root变了，插入操作是错的。不如直接建一棵新的平衡树插点，然后在裂开合并三段即可。对于最大子列和，用区间合并的思想求；对于区间翻转，用平衡树反转的思想求；很板的题，但是很有必要写。注意下放标记的顺序。
洛谷 P2042 [NOI2005] 维护数列(splay)
最新发布
weixin_74174531的博客
07-11 583
(1)插入，当需要再数列第pos个数字后面插入一段序列时，我们需要splay(pos,0),splay(pos+1,pos)，将pos旋转到根，将pos+1旋转到pos的下面，此时，我们只需要构建出插入的序列，然后将其插入到pos+1节点的左子树上即可。(2)删除，当需要删除pos开始的tot个数字时，我们只需要splay(pos-1,0),splay(pos+tot,pos-1)，然后将pos+tot的左子树删除即可。(3)如果需要修改一个区间的话，我们就直接将它的懒标记更新。(5)区间最大子序列ms。
洛谷 P2042 [NOI2005]维护数列（平衡树）
whisperlzw的博客
04-05 361
题目描述 请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 输入输出格式 输入格式： 输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数，M 表示要进行的操作数目。 第 2 行包含 N 个数字，描述初始时的数列。 以下 M 行，每行一条命令，格式参见问题描述中的表格 输出格式： ...
P2042 [NOI2005]维护数列 fhq treap
qq_44784019的博客
08-28 241
P2042 [NOI2005]维护数列 题目的链接 众多平衡树独爱fhq 题目 有好多种操作： 1、添加一堆数 2、删除一个区间里的数 3、把一个区间里的数全变成同一个数 4、反转一个区间 5、求区间和 6、求最大的连续子序列的和。 因为要求连续的子序列的和，就想到了线段树区间合并。 这个，，应该可以想到。 所以就维护 lnum,rnum,num 做的时候的zz问题 崩溃了~~ 做的时候 我tmd 崩溃了，， 快神经了啊 我 一、添加一堆数我刚开始一个一个添加，， 因为方便（tle） 二、反转一个区间的时候
[NOI 2005] 维护数列 splay
九野的博客
05-30 1730
题目链接：http://www.lydsy.com:808/JudgeOnline/problem.php?id=1500 写的比较小心，还好没有经历虐心的wa。。 数据结构的经典神题。。敲完才发现搞了250行。。 思路还是很简单的，和线段树的求最大子段和一样，左连续右连续什么的，， 对于区间操作都把这个区间转到根的右子树的左子树下。。 1、这题需要搞个内存池，开始t
NOI2005 维护数列(splay)
weixin_30662539的博客
12-15 117
学了半天平衡树，选择了一道题来写一写，发现题目是裸的splay模板，但是还是写不好，这个的精髓之处在于在数列的某一个位置加入一个数列，类似于treap里面的merge，然后还学到了题解里面的的回收空间做法，利用时间换取空间也是一种非常不错的做法，由于题目中有区间翻转的操作，所以只能用splay来写，然后对于一些区间最大值和区间最大子序列的询问我们可以用类似于线段树的合并操作来维护，总的来说这是一道...
noi2005维护数列 splay
黑历史
03-09 299
用splay来维护数列的一道很好的模版练习题 有些要注意的地方： 不用指针来实现splay的话要注意内存回收，不然就会无限RE+TLE凡是有对序列进行修改的操作都要up一下reverse的时候要注意交换左起最大连续和跟右起最大连续和 代码： #include #include #include #include #include #include #include #include
NOI2005 维修数列 Splay
rgnoH的博客
11-28 279
题目大意： 给出一个初始序列，要求实现下面的操作： 1.在当前序列的某个位置插入连续的若干个元素； 2.删除当前序列的某一段元素； 3.将当前序列中某一段元素全部修改为某个值； 4.翻转某个区间； 5.求当前序列某一段元素的总和； 6.求出当前序列中连续和的最大值。
P2042 [NOI2005]维护数列 splay
haiku的博客
11-09 210
学块状链表的时候找到的这个题，看了大佬的思路发现splay真香，块状链表虽然好理解，但写起来真的有点烦。 P2042 [NOI2005]维护数列 对一个数列进行插入，删除，修改（统一置为某数），区间翻转，区间求和，整体最大子列和。 用splay维护序列的基本操作：先通过旋转把要操作的区间单独拎出来，比如要操作从k开始的tot个数，那就先把下标k-1对应的结点转到整棵树的根，然后把k+tot转到根的...
P2042 [NOI2005] 维护数列 题解
Plozia 的小窝
12-29 768
一道数据结构题，细节特别多。
Link-Cut-Tree动态树实操：Splay与LCT在区间操作和树维护中的应用
在实际应用中，例如NOI2005D1T2维修序列的问题，对于Splay树的初学者来说可能颇具挑战，但通过理解和掌握LCT的概念，这些问题可以迎刃而解。LCT能够支持更复杂的操作，如子树修改和换根，其最坏时间复杂度为O(nlog^...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值