【NOI 2005】 维修数列

最新推荐文章于 2019-05-05 09:50:00 发布
最新推荐文章于 2019-05-05 09:50:00 发布
阅读量231 收藏
点赞数
分类专栏： 伸展树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/even_bao/article/details/79503004
版权

【题目链接】

           点击打开链接

【算法】

           本题所运用的也是Splay的区间操作，但是实现较为困难

            INSERT操作

            将pos splay至根节点，pos+1 splay至根节点的右节点，然后对根节点的右节点的左节点建树即可

            DELETE操作

            将l-1 splay至根节点， r+1 splay至根节点的右节点，直接“砍断”根节点的右节点的左节点

            MAKE_SAME操作

            将l-1 splay至根节点，r+1 splay至根节点的右节点，给根节点的右节点的左节点打上标记

            REVERSE操作

            将l-1 splay至根节点，r+1 splay至根节点的右节点，给根节点的右节点的左节点打上标记

            GET_SUM操作

            将l-1 splay至根节点，r+1 splay至根节点的右节点，直接输出根节点的右节点的左节点的sum

            MAX_SUM操作

            此操作的实现类似于树形DP ：

            我们不妨给每个节点增加三个域

            lmax ：从这个节点所代表的区间的左端点开始向右延伸的最大和

            rmax ：从这个节点所代表的区间的右端点开始像左延伸的最大和

            max ： 该节点所代表区间的最大连续子段和

            那么，lmax该如何取值？

            令根节点为root，根节点的左儿子为lc，根节点的右儿子为rc

            我们可以分情况讨论 ：

            若lmax[root]不包括root，则lmax[root] = lmax[lc]

            若lmax[root]包括root，那么 ： 若不向右继续延伸，则lmax[root] = tot[lc] + val[root]，若向右延伸，

            则lmax[root] = tot[lc] + val[root] + lmax[rc]

            我们只要在这三者中取最大值就可以了

            rmax同理

            那么，max又该如何取值呢？

            我们还是分情况讨论 ：

            令根节点为root，根节点的左儿子为rc，根节点的右儿子为rc

            若max[root]不包括root，则max[root] = max{max[lc],max[rc]}

            若max[root]包括root，那么 : 若不向右也不向左延伸，则max[root] = val[root],若向左延伸，

            则max[root] = val[root] + rmax[lc]

            若向右延伸，则 ：

             max[root] = val[root] + lmax[rc]

            若两边同时延伸，则 ：

            max[root] = val[root] + rmax[rc] + lmax[lc]

            只需在这五者中取最大值即可

            关于内存池 ：

            由于本题数据量较大，我们要进行内存回收，内存回收方法如下 ：

            我们建立一个内存池，开始时将所有可用空间都放入内存池，插入一个节点时，我们从内存池弹出一个节点，

            分配给这个节点，删除时，我们将要删除的节点放回内存池，如果是删除一棵子树，则将整棵子树放回内存池

            这个内存池可以用栈，队列，链表等许多数据结构来维护，笔者选用的是栈，由于维护方法比较简单，笔者不再赘述

【代码】

          本题的细节很多，写代码时一定要严谨！

         

#include<bits/stdc++.h>
using namespace std;
#define MAXN 20000
#define MAXX 500000
const int INF = 2e9;

int i,N,M,tot,pos,val;
int a[MAXX+10];
char opt[10];
stack<int> stk;

template <typename T> inline void read(T &x) {
		int f = 1; x = 0;
		char c = getchar();
		for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
		for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
		x *= f;
}

template <typename T> inline void write(T x) {
    if (x < 0) { putchar('-'); x = -x; }
    if (x > 9) write(x/10);
    putchar(x%10+'0');
}

template <typename T> inline void writeln(T x) {
    write(x);
    puts("");
}

struct Splay {
		int root;
		struct Node {
				int fa,son[2],size,lmax,rmax,tot,
						Max,val,lazy;
				bool rev;
		} Tree[MAXX+10];
		inline bool get(int x) {
				return Tree[Tree[x].fa].son[1] == x;
		}
		inline void build(int index,int l,int r) {
				int id,mid;
				mid = (l + r) >> 1;
				Tree[index].lazy = INF;
				Tree[index].rev = 0;
				Tree[index].val = a[mid];
				if (l == r) {
						Tree[index].size = 1;
						Tree[index].lmax = Tree[index].rmax = Tree[index].Max = Tree[index].tot = a[mid];
						return;
				}
				if (l < mid) {
						id = stk.top();
						stk.pop();
						Tree[index].son[0] = id;
						Tree[id].fa = index;
						build(id,l,mid-1);
				}
				if (mid < r) {
						id = stk.top();
						stk.pop();
						Tree[index].son[1] = id;
						Tree[id].fa = index;
						build(id,mid+1,r);
				}
				update(index);
		}
		inline void update(int index) {
				if (!index) return;
				Tree[index].tot = Tree[Tree[index].son[0]].tot + Tree[Tree[index].son[1]].tot + Tree[index].val;
				Tree[index].size = Tree[Tree[index].son[0]].size + Tree[Tree[index].son[1]].size + 1;
				Tree[index].lmax = max(Tree[Tree[index].son[0]].lmax,Tree[Tree[index].son[0]].tot+max(Tree[Tree[index].son[1]].lmax,0)+Tree[index].val);
				Tree[index].rmax = max(Tree[Tree[index].son[1]].rmax,Tree[Tree[index].son[1]].tot+max(Tree[Tree[index].son[0]].rmax,0)+Tree[index].val);
				Tree[index].Max = max(Tree[Tree[index].son[0]].Max,max(Tree[Tree[index].son[1]].Max,Tree[index].val+max(Tree[Tree[index].son[0]].rmax,0)+max(Tree[Tree[index].son[1]].lmax,0)));
		}
		inline void pushdown(int index) {
				int tmp;
				if (Tree[index].lazy != INF) {
						tmp = Tree[index].lazy;
						Tree[index].lazy = INF;
						if (Tree[index].son[0]) Tree[Tree[index].son[0]].tot = Tree[Tree[index].son[0]].size * tmp;
						if (Tree[index].son[1]) Tree[Tree[index].son[1]].tot = Tree[Tree[index].son[1]].size * tmp;
						if (Tree[index].son[0]) Tree[Tree[index].son[0]].val = tmp;
						if (Tree[index].son[1]) Tree[Tree[index].son[1]].val = tmp;	
						if (Tree[index].son[0]) Tree[Tree[index].son[0]].lmax = Tree[Tree[index].son[0]].rmax = Tree[Tree[index].son[0]].Max = max(tmp,Tree[Tree[index].son[0]].size*tmp);
						if (Tree[index].son[1]) Tree[Tree[index].son[1]].lmax = Tree[Tree[index].son[1]].rmax = Tree[Tree[index].son[1]].Max = max(tmp,Tree[Tree[index].son[1]].size*tmp);
						if (Tree[index].son[0]) Tree[Tree[index].son[0]].lazy = tmp;
						if (Tree[index].son[1]) Tree[Tree[index].son[1]].lazy = tmp;
				}
				if (Tree[index].rev) {
						swap(Tree[index].son[0],Tree[index].son[1]);
						swap(Tree[Tree[index].son[0]].lmax,Tree[Tree[index].son[0]].rmax);
						swap(Tree[Tree[index].son[1]].lmax,Tree[Tree[index].son[1]].rmax);
						Tree[Tree[index].son[0]].rev ^= 1;
						Tree[Tree[index].son[1]].rev ^= 1;
						Tree[index].rev = 0;
				}
		}
		inline int query_pos(int x) {
				int index = root;
				while (true) {
						pushdown(index);
						if (x > Tree[Tree[index].son[0]].size) {
								x -= Tree[Tree[index].son[0]].size;
								if (x == 1) return index;
								--x;
								index = Tree[index].son[1];
						} else index = Tree[index].son[0];
				}		
		}
		inline void clear(int index) {
				Tree[Tree[index].fa].son[get(index)] = 0;
				Tree[index].fa = 0;
				stk.push(index);
				if (Tree[index].son[0]) clear(Tree[index].son[0]);
				if (Tree[index].son[1]) clear(Tree[index].son[1]);	
		}
		inline void Insert(int index) {
				int id;
				int x = query_pos(index),
						y = query_pos(index+1);
				splay(x,0); splay(y,root);
				id = stk.top(); 
				stk.pop();
				build(id,1,tot);
				Tree[Tree[root].son[1]].son[0] = id;
				Tree[id].fa = Tree[root].son[1];
				update(Tree[root].son[1]);
				update(root);
		}
		inline void rotate(int x) {
				int f = Tree[x].fa,g = Tree[f].fa,
				tmpx = get(x),tmpf = get(f);
				pushdown(f); pushdown(x);
				if (!f) return;
				Tree[f].son[tmpx] = Tree[x].son[tmpx^1];
				if (Tree[x].son[tmpx^1]) Tree[Tree[x].son[tmpx^1]].fa = f;
				Tree[x].son[tmpx^1] = f;
				Tree[f].fa = x;
				Tree[x].fa = g;
				if (g) Tree[g].son[tmpf] = x;
				update(f);
				update(x);
		}
		inline void splay(int x,int pos) {
				int f;
				for (f = Tree[x].fa; (f = Tree[x].fa) != pos; rotate(x)) {
						if (Tree[f].fa != pos) 
								rotate(get(f) == get(x) ? (f) : (x));
				}
				if (!pos) root = x;
		}
		inline void modify(int l,int r,int v) {
				int x = query_pos(l-1),
						y = query_pos(r+1);
				splay(x,0); splay(y,root);
				int tmp = Tree[Tree[root].son[1]].son[0];
				Tree[tmp].val = Tree[tmp].lazy = v;
				Tree[tmp].tot = v * Tree[tmp].size;
				Tree[tmp].lmax = Tree[tmp].rmax = Tree[tmp].Max = max(Tree[tmp].size*v,v);
				update(Tree[root].son[1]);
				update(root);
		}
		inline void reverse(int l,int r) {
				int x = query_pos(l-1),
						y = query_pos(r+1);
				splay(x,0); splay(y,root);
				Tree[Tree[Tree[root].son[1]].son[0]].rev ^= 1;
				swap(Tree[Tree[Tree[root].son[1]].son[0]].lmax,Tree[Tree[Tree[root].son[1]].son[0]].rmax);
		}
		inline void erase(int l,int r) {
				int x = query_pos(l-1),
						y = query_pos(r+1);
				splay(x,0); splay(y,root);
				clear(Tree[Tree[root].son[1]].son[0]);
				Tree[Tree[root].son[1]].son[0] = 0;
				update(Tree[root].son[1]);
				update(root);
		}
		int get_sum(int l,int r) {
				int x = query_pos(l-1),
						y = query_pos(r+1);
				splay(x,0); splay(y,root);
				return Tree[Tree[Tree[root].son[1]].son[0]].tot;
		}
		int max_sum(int l,int r) {
				int x = query_pos(l-1),
						y = query_pos(r+1);
				splay(x,0); splay(y,root);
				return Tree[Tree[Tree[root].son[1]].son[0]].Max;
		}
} T;

int main() {
		
		read(N); read(M);
		
		for (i = 2; i <= MAXX; i++) stk.push(i);
		
		a[1] = a[N+2] = -INF;
		for (i = 2; i <= N + 1; i++) read(a[i]);
		
		T.Tree[0].lmax = T.Tree[0].rmax = T.Tree[0].Max = -INF;
		T.root = 1;
		T.build(1,1,N+2);
		
		while (M--) {
				scanf("%s",&opt);
				if (opt[0] == 'I') {
						read(pos); read(tot);
						for (i = 1; i <= tot; i++) read(a[i]);
						T.Insert(pos+1);
						N += tot;
				}	else if (opt[0] == 'D') {
						read(pos); read(tot);
						T.erase(pos+1,pos+tot);
						N -= tot;
				} else if (opt[0] == 'M' && opt[2] == 'K') {
						read(pos); read(tot); read(val);
						T.modify(pos+1,pos+tot,val);
				} else if (opt[0] == 'R') {
						read(pos); read(tot);
						T.reverse(pos+1,pos+tot);
				} else if (opt[0] == 'G') {
						read(pos); read(tot);
						writeln(T.get_sum(pos+1,pos+tot));
				} else if (opt[0] == 'M' && opt[2] == 'X') {
						writeln(T.max_sum(2,N+1));
				}                          
		}
		
		return 0;
	
}

even_bao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOI2005维护数列原题
02-17
维护数列 【问题描述】 请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格） 操作编号 输入文件中的格式 说明 1. 插入 INSERT_posi_tot_c1_c2_.....
NOI 2005-2009试题
03-29
"NOI 2005-2009试题"的资源包含了这五年间的全部竞赛题目，对于学习信息学和准备参赛的学生来说是宝贵的参考资料。 NOI赛事通常涵盖算法设计、编程技能以及问题解决能力等多方面。比赛试题通常分为几个类别，包括但...
[NOI2005]维修数列
dilei7762的博客
01-09 124
Description Input 输入的第11行包含两个数NN和M(M≤20000)M(M≤20000)，NN表示初始时数列中数的个数，MM表示要进行的操作数目。 第22行包含NN个数字，描述初始时的数列。 以下MM行，每行一条命令，格式参见问题描述中的表格。 任何时刻数列中最多含有500000500000个数，数列中任...
noi 2005维修数列
diyan5166的博客
08-27 240
OI生涯中最想过的一题=v= splay加上各种各样的操作，样例又不敢拿来调了。。。 感觉指针写splay好难调，所以以后写splay都用数组吧（其实是因为黄大神也用数组orz） 好像是2小时敲完。。debug了2天TAT一开始把操作6和某提混了。。。 然后搞来搞去才发现读入有个毛病0A0 再然后又发现一直以来自己的pushdown和别人是不一样的。。（那些题我居然过了。。...
[BZOJ1500][NOI2005]维修数列
weixin_34407348的博客
05-05 75
[NOI2005]维修数列 题面 请写一个程序，要求维护一个数列，支持以下 6 种操作： 请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格 Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻数列中最多含有500 ...
noi2005测试数据
09-13
【标题】"noi2005测试数据" 指的是全国青少年信息学奥林匹克（NOI）2005年比赛的测试用例。这是一个针对编程竞赛的专题，其中包含的问题和数据集用于训练参赛者解决算法问题的能力。NOI是中国最高级别的中学生计算机...
NOI2021Day2.pdf
08-06
NOI2021Day2
NOI 2021 统一省选
04-16
【NOI 2021 统一省选】是中国计算机学会（CCF）组织的一场重要的编程竞赛，旨在选拔优秀的青少年参加国际信息学奥林匹克竞赛（IOI）。这个活动为广大学子提供了一个展示和提升自己算法设计与编程能力的平台，同时也...
【bzoj1500】[NOI2005]维修数列 Splay
Oxer的专栏
12-29 2267
终于打败大boss了，耗时一下午。 应该是splay维护序列题型的巅峰了吧。 这道题不能单纯的开点，因为会MLE，所以要用回收节点的过程。 说一下搞法吧： 1、插入，提取区间，递归建树 2、删除，提取区间，把删去的点用一个栈储存下来 3、修改，提取区间，打个标记 4、翻转，提取区间，打个标记 5、求和、最大连续子段和，维护一下就可以了。 WA点： 这道题不用开longlong，
bzoj1500 [NOI2005]维修数列解题报告
ACoder
02-17 2583
Bzoj 1500: [NOI2005]维修数列 解题报告 题目原文 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 10429  Solved: 3218 [Submit][Status][Discuss] Description Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数
1500: [NOI2005]维修数列
蒟蒻的Bzoj记录
03-26 239
题目链接题目大意：维护一个数列，支持一堆操作（懒得写了）题解：上fhq treap……我的收获：2333#include <cstdio> #include <queue> #include <cstdlib> using namespace std;#define N 500010 #define INF 0x3f3f3f3fint n,m,root,cnt; int ch[N][2],siz[N
[BZOJ1500][NOI2005]维修数列（splay）
zyf2000
12-04 892
题目描述传送门题解splay模板题（笑 这题是我今年1月左右看到的。记得当时只调过了样例然后交上去过了一个点就用了我一天的时间。果然我还是太傻逼。 填上了好大一个坑。 前5个都是splay的基础操作，就是第6个比较麻烦。因为要维护区间最大连续子序列和，可以维护3个值：Max子树最大连续子序列和，maxl子树自左端起最大连续子序列和，maxr子树自右端起最大连续子序列和。注意这里的Max是不允许
bzoj 1500: [NOI2005]维修数列（splay大模板）
zzk_233的博客
09-15 217
没什么好说的，就是各种操作。 st数组用来回收内存，root为根，tot为点数，lmax为左端最大值，rmax为右端最大值，smax为全区 间最大值，sum为区间和（这部分操作见），val为权值，son【2】为左右子节点编号，siz为大小， xg为是否有修改标记，fz为是否有反转标记。（注释部分可以不写，有助于理解）。 #include&amp;lt;cstdio&amp;gt; #include&amp;lt;...
NOI2.0评测系统使用指南、NOI Linux 2.0 和 Vim 指北.pdf
最新发布
10-28
"该资源是一份综合指南，涵盖了NOI2.0评测系统、NOILinux 2.0操作系统以及Vim编辑器的使用方法。它提供了多个在线视频教程链接和详细的文章，帮助用户了解和掌握这些工具在编程竞赛中的应用，特别是针对信奥竞赛(C++...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值