jzoj3658. 【NOI2014模拟】文本编辑器(editor)

最新推荐文章于 2023-04-14 18:24:04 发布
最新推荐文章于 2023-04-14 18:24:04 发布
阅读量305 收藏
点赞数 1
分类专栏： OJ题解 Treap Treap-非旋Treap Treap-非旋Treap-可持久化非旋Treap 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gmh77/article/details/82952960
版权
OJ题解 同时被 3 个专栏收录
146 篇文章 0 订阅
订阅专栏
优化
16 篇文章 0 订阅
订阅专栏
Treap
4 篇文章 0 订阅
订阅专栏

题目描述

Description
在这里插入图片描述
Input
在这里插入图片描述
Output
对于每个询问输出一个字符表示答案。

Sample Input
9
I 0 o
I 0 r
I 0 z
R 1 3
Q 1
D 1 1
Q 1
C 2 2 0
Q 1

Sample Output
orz

Data Constraint
在这里插入图片描述

题解

因为有复制操作，所以要用可持久化平衡树来搞
其它操作相同，复制操作时先复制根，然后取出要复制的节点（split*2），最后插入（split*1，merge*2）

因为是区间操作，所以下传标记时也要新建孩子节点

优化

1、每次如果有标记才下传（新建节点）
2、（自己想的）如果一个节点有多条边指向它时才新建
比较玄学，但很有效
要注意当一个点只剩一个父亲时，记录的父亲可能会错
比如这样
在这里插入图片描述
其中黑色边表示向下指向孩子的边，红色边表示记录的父亲，灰色边表示将要复制的边（即非原本父亲指向它的边）
然后新建节点后变成了这样
在这里插入图片描述
显然下面的节点的父亲错了
解决方法是每次向下走时都将儿子的父亲设为当前点，这样一定能保证其正确性
就算当前的父亲时错的也无所谓，因为最后只剩一个父亲时一定是对的

3、（构思中）每次把下传标记分成左右儿子分别下传，然后再记录每条边出现时复制的原节点，之后只有向某一方向走时才新建节点
不过这样复制信息就会很eggache，反正都过了就无所谓了

4、查找时可以不同新建节点，只需要记录下当前的儿子是否翻转
向下走就异或一下左/右儿子的编号（0/1）

5、随机的值可以不用数组记录，只需要
r a n d ( ) % ( s i z e [ a ] + s i z e [ b ] ) &lt; s i z e [ a ] rand()\%(size[a]+size[b])&lt;size[a] rand()%(size[a]+size[b])<size[a]
这样可以使保证子树较大的树高概率被放在上面，使树高均摊 l o g &ThickSpace; n log\;n logn

6、O3大法好
2000byte的O3问你怕不怕

*7、OJ上的随机数范围是0~2147483647，而本地是0~32767
马德坑了我两个礼拜

code

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define Max 20000001
using namespace std;

int tr[Max][2];
int sum[Max];
int fa[Max];
int num[Max];
bool rev[Max];
int FA[Max]; //nµÄ¸¸Ç׸öÊý
int N,n,Q,i,j,k,l,x,y,z,X,Fs,Ls,I,J,root,Find,Find2,now,fa1,fa2,Root,ROOT,root2;
char type,ch;

inline int getint() {char c; register int ret=0; for(c=getchar(); c<'0' || c>'9'; c=getchar()); for(; c>='0'&&c<='9'; c=getchar()) ret=ret*10+c-'0'; return ret; }
inline char getChar()
{
	char ch=getchar();
	for (; ch<'A' || ('Z'<ch && ch<'a') || 'z'<ch; ch=getchar());
	return ch;
}

inline void up(register int t) {sum[t]=sum[tr[t][0]]+sum[tr[t][1]]+1;}
inline void swap(register int &a,register int &b) {int c=a;a=b;b=c;}

inline int copy(register int root)
{
	if (now)
	{
		n++;
		tr[n][0]=tr[root][0]; FA[tr[n][0]]++;
		tr[n][1]=tr[root][1]; FA[tr[n][1]]++;
		num[n]=num[root];
		sum[n]=sum[root];
		rev[n]=rev[root];
	}
	
	return n;
}

inline void down(register int t)
{
	if (rev[t] && t)
	{
		swap(tr[t][0],tr[t][1]);
		
		rev[tr[t][0]]^=1;
		rev[tr[t][1]]^=1;
		rev[t]=0;
	}
}

inline void New(register int t,register int x)
{
	if (t && tr[t][x])
	{
		fa[tr[t][x]]=t;
		
		if (FA[tr[t][x]]>1)//优化2
		{
			FA[tr[t][x]]--;
			
			n++;
			tr[n][0]=tr[tr[t][x]][0]; FA[tr[n][0]]++;
			tr[n][1]=tr[tr[t][x]][1]; FA[tr[n][1]]++;
			sum[n]=sum[tr[t][x]];
			fa[n]=t; //not fa[tr[t][x]]
			num[n]=num[tr[t][x]];
			rev[n]=rev[tr[t][x]];
			FA[n]=1;
			
			tr[t][x]=n;
		}
	}
}

inline void merge(register int Fa,register int son,register int x,register int y)
{
	if (x && rev[x]) New(x,0),New(x,1),down(x);//优化1
	if (y && rev[y]) New(y,0),New(y,1),down(y);
	
	if (rand()%(sum[x]+sum[y])<sum[x])//优化5
	{
		if (Root==-1) Root=x;
		New(x,1);
		
		tr[Fa][son]=x;
		FA[x]+=(!fa[x] && Fa);
		fa[x]=Fa;
		
		if (tr[x][1])
		merge(x,1,tr[x][1],y);
		else
		{
			if (x)
			{
				sum[x]+=sum[y];
				tr[x][1]=y;
			}
			FA[y]+=(!fa[y]);
			fa[y]=x;
		}
	}
	else
	{
		if (Root==-1) Root=y;
		New(y,0);
		
		tr[Fa][son]=y;
		FA[y]+=(!fa[y] && Fa);
		fa[y]=Fa;
		
		if (tr[y][0])
		merge(y,0,x,tr[y][0]);
		else
		{
			if (y)
			{
				sum[y]+=sum[x];
				tr[y][0]=x;
			}
			FA[x]+=(!fa[x]);
			fa[x]=y;
		}
	}
	
	if (Fa) up(Fa);
}

inline void split(register int Fa1,register int Fa2,register int t,register int k) //fa1±íʾºó°ë¶ÎµÄ¸ù£¬fa2±íʾǰ°ë¶ÎµÄ¸ù
{
	if (rev[t]) New(t,0),New(t,1),down(t);
	
	if (sum[tr[t][0]]>=k)
	{
		New(t,0);
		if (!fa1) fa1=t;
		
		if (fa[t])
		{
			FA[t]-=(!Fa1);
			tr[fa[t]][tr[fa[t]][1]==t]=0;
			up(fa[t]);
		}
		
		tr[Fa1][0]=t;
		fa[t]=Fa1;
		
		if (k && tr[t][0])
		split(t,Fa2,tr[t][0],k);
		
		if (Fa1) up(Fa1);
	}
	else
	{
		New(t,1);
		if (!fa2) fa2=t;
		
		if (fa[t])
		{
			FA[t]-=(!Fa2);
			tr[fa[t]][tr[fa[t]][1]==t]=0;
			up(fa[t]);
		}
		
		tr[Fa2][1]=t;
		fa[t]=Fa2;
		
		if (tr[t][1])
		split(Fa1,t,tr[t][1],k-sum[tr[t][0]]-1);
		
		if (Fa2) up(Fa2);
	}
}

inline int find(register int t,register int k,register bool Rev)
{
	Rev^=rev[t]; //优化4
	
	if (sum[tr[t][Rev]]>=k)
	return find(tr[t][Rev],k,Rev);
	else
	if (sum[tr[t][Rev]]+1==k)
	return num[t];
	else
	return find(tr[t][!Rev],k-sum[tr[t][Rev]]-1,Rev);
}

int main()
{
	freopen("editor.in","r",stdin);
	freopen("editor.out","w",stdout);
	
	srand(time(NULL));
	
	Q=getint();
	
	n=0;
	now=0;
	fo(I,1,Q)
	{
		type=getChar();
		switch (type)
		{
			case 'I':
				{
					x=getint();
					ch=getChar();
					
					n++;N=n;
					num[n]=ch-'a';
					sum[n]=1;
					
					if (!now)
					root=N;
					else
					{
						Root=-1;
						if (!x)
						merge(0,0,N,root);
						else
						if (x==now) 
						merge(0,0,root,N);
						else
						{
							fa1=0;fa2=0;
							split(0,0,root,x);
							
							merge(0,0,fa2,N);
							
							ROOT=Root;
							Root=-1;
							merge(0,0,ROOT,fa1);
						}
						
						root=Root;
					}
					
					now++;
					break;
				}
				
			case 'D':
				{
					x=getint();
					y=getint();
					
					j=0;k=0;
					if (x>1)
					{
						fa1=0;fa2=0;
						split(0,0,root,x-1);
						
						j=fa2;
						root=fa1;
					}
					if (y<now)
					{
						fa1=0;fa2=0;
						split(0,0,root,y-x+1);
						
						k=fa1;
					}
					
					if (j && k)
					{
						Root=-1;
						merge(0,0,j,k);
						root=Root;
					}
					else
					if (j) root=j;
					else
					if (k) root=k;
					
					now-=(y-x+1);
					break;
				}
				
			case 'C':
				{
					x=getint();
					y=getint();
					z=getint();
					
					root2=copy(root);
					
					j=0;k=0;
					if (x>1)
					{
						fa1=0;fa2=0;
						split(0,0,root,x-1);
						
						j=fa2;
						root=fa1;
					}
					if (y<now)
					{
						fa1=0;fa2=0;
						split(0,0,root,y-x+1);
						
						k=fa1;
						root=fa2;
					}
					
					Root=-1;
					if (!z)
					merge(0,0,root,root2);
					else
					if (z==now) 
					merge(0,0,root2,root);
					else
					{
						fa1=0;fa2=0;
						split(0,0,root2,z);
						
						merge(0,0,fa2,root);
						
						ROOT=Root;
						Root=-1;
						merge(0,0,ROOT,fa1);
					}
					
					root=Root;
					
					now+=(y-x+1);
					break;
				}
				
			case 'R':
				{
					x=getint();
					y=getint();
					
					j=0;k=0;
					if (x>1)
					{
						fa1=0;fa2=0;
						split(0,0,root,x-1);
						
						j=fa2;
						root=fa1;
					}
					if (y<now)
					{
						fa1=0;fa2=0;
						split(0,0,root,y-x+1);
						
						k=fa1;
						root=fa2;
					}
					
					rev[root]^=1;
					
					Root=-1;
					if (j && k)
					{
						merge(0,0,j,root);
						
						ROOT=Root;
						Root=-1;
						merge(0,0,ROOT,k);
					}
					else
					if (j)
					merge(0,0,j,root);
					else
					if (k)
					merge(0,0,root,k);
					
					if (Root>-1)
					root=Root;
					break;
				}
				
			case 'Q':
				{
					x=getint();
					putchar(find(root,x,0)+'a');
					break;
				}
		}
	}
}

后记

因为没有压代码所以看上去很清真
对着表改真舒服

接下来要开始搞NOIP了

参考

https://blog.csdn.net/jpwang8/article/details/79211007
https://blog.csdn.net/jokerwyt/article/details/81710270

gmh77
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
简单的行文本编辑器 实现文本的基本操作
06-23
设计的是一个简单的行编辑器，模拟实现诸如Turbo C EDIT等现有的编辑器对文本文件的录入和编辑功能。可以实现如下功能 1. 文档的录入与保存：能录入一个文本文件并在编辑域显示，并能以数据形式存盘，在保存过程中实施加密。 2. 文档打开与编辑：能打开一个txt格式的文本文件，并在编辑域显示，还能对文档进行插入和替换字符操作，并显示修改后的文档。 3. 加密：设计一个简单的加密算法，能对文本实施加密，并显示明文和密文。 4. 实现文档编辑过程的图形化操作，能用上、下、左、右移位键进行定位。
jzoj3658 [NOI2014模拟] 文本编辑器(editor)
olahiuj的博客
01-30 398
Description 给定m个操作，包括插入一个字符、删除一段连续的字符、翻转一段连续的字符、复制一段连续的字符到指定位置、查询指定位置上的字符 Solution 第一眼以为splay水题，结果发现并不会复制操作。气急败坏地写了个链表怒艹20分 这里实际上是可持久化treap。所谓可持久化treap是一种无旋转操作的treap，通过split（分裂）和merge（合并）维护区间。
JZOJ5249. 【NOIP2017提高A组模拟8.10】文本编辑器
lijf2001的博客
08-10 316
分析我们发现，在这么多操作之中，R翻转是最难处理的。 那我们就先考虑如何将一个区间翻转。 splay？ 这样可以拿到90分，如何拿到100分。 如何快速翻转一个区间，我们想到了双头队列， 对于翻转整个队列就是交换队头队尾。我们将整个序列依次分为一个栈，左指针，一个双头队列，右指针，一个栈。 这样每一个操作就可以O(1)解决。code#include<cstdio> #include<io
【JZOJ 5249】【NOIP2017提高A组模拟8.10】文本编辑器
08-10 409
DescriptionSolution这道题用Splay是一道版子题， 但很遗憾，只有90分， 那O(n)怎么做呢？我们发现，对于全局的数，可以用2个栈，1个队列表示： 设两个光标位置为l,r， 两个栈分别表示l前面的数、r后面的数，队列表示l~r中间的数， 那么对于简单的移动操作，直接做即可， 对于翻转，我们发现，直接打上标记即可，在光标移动的时候判断一下即可， 当然还有特殊情况：当
jzoj5249 【NOIP2017提高A组模拟8.10】文本编辑器 (序列修改类问题，数据结构)
一位蒟蒻的小博客
08-10 387
题面分析splay的话是过不了最后一个点的。 显而易见的我们可以考虑链表+tag，但是细节很多。 因为翻转只翻转两个光标中间的地方，我们考虑将中间的放到一个队列里，然后左右两边分别开一个栈存。 翻转的话就调换一下队列的head与tail，并且将正方向取反。 +正方向就相当于在序列上的后一个位置。 想一想，这样设计的话别的操作不需要特殊考虑，和没翻转的情况一样做就行。 还需要考虑l,r光标
NOI2009.rar_.noi20_Noi2009 P_noi20
09-23
【标题】"NOI2009.rar_.noi20_Noi2009 P_noi20" 涉及的是2009年全国青少年信息学奥林匹克（NOI）的比赛资料，其中包含了选手的解题报告，源代码，问题注解以及解答。 【描述】"最新noi2099解题报告.包含源程序.标注...
NOI.OpenJudge.cn离线chm
10-12
Noi.openjudge.cn的离线版本，包含了所有试题。由于这个网站老是崩溃或者维护，就扒下来搞了一个离线版本。可以当成手册没网的时候用来刷题。
noi模拟题1
07-22
【标题】"noi模拟题1"所指的是一场针对全国信息学奥林匹克（NOI）的模拟竞赛题目。NOI是中国青少年计算机程序设计竞赛的一项重要活动，旨在培养青少年的计算机编程技能和算法理解能力。这类模拟题通常由资深教练或...
noi模拟题3
07-22
【标题】"noi模拟题3"涉及到的是全国青少年信息学奥林匹克（NOI）的模拟题目，这是一项针对中学生的信息学竞赛。"AFO后发福利"可能是指某个知名的信息学竞赛选手或教练（AFO）在比赛结束后分享了一些额外的学习资源...
noi模拟题5
07-23
【全国信息学奥林匹克模拟题5】是一场针对信息学竞赛选手的重要练习，通常在NOI（全国青少年信息学奥林匹克）之前进行，旨在帮助参赛者熟悉比赛环境和提高解题能力。"AFO后发福利"可能指的是某个知名的信息学竞赛...
北航第四次作业——文本编辑操作模拟（简）a
m0_74019378的博客
04-14 142
先从键盘输入一行字符串，表示已经经过n步编辑操作后的文本串，然后在下一行输入一个正整数n，并分行输入n步插入或删除操作（表示按时间先后顺序已进行的操作），格式如上所述。表示将从pos位置开始删除n个字符（各数据间以一个空格分隔），若要删除的字符个数多于已有字符个数（即在文本中从pos开始的字符个数小于n），则按实际字符数删除即可。随后执行了三次删除操作，又执行了三次撤销操作，最后输入的-1表示编辑操作结束，在屏幕上输出最终编辑后的文本串。3、删除操作中的位置pos大于等于0，并且小于当前文字的字符个数；
数据结构-模拟文本编辑操作（栈）-C语言-【读取一行字符串该行字符串是已经过n步编辑操作后的结果。读取已执行操作，在继续编辑，直至结束获得字符串】
qq_37746855的博客
04-21 466
这里写目录标题题目描述题目分析实现思路实现代码 题目描述 【问题描述】 编写一程序模拟文本编辑操作。首先从标准输入读取一行字符串（字符个数不超过512），该行字符串是已经过n（大于0，小于等于10）步编辑操作后的结果。然后从下一行读取n，以及已发生过的n步编辑操作，编辑操作分行输入，输入格式为： op pos str 其中op为编辑操作命令编码（在此只有插入和删除操作，1表示插入或2表示删除操作）；pos表示插入或删除的位置；str表示已经插入或删除的字符串（中间没有空格）。各数据间以一个空格分隔。 然后在
jzoj5844. c
某司机的黑车
08-24 262
题目描述 Description 给定一个无向连通图，n 个点（下标从 1 开始），m 条边，每条边有一个颜色。保证无自环，没有长度超过 2 的简单环。 现有 q 个询问：给出两个点 x、y，选择一条 x 到 y 简单路径（不经过重复的点），经过的边将形成一个颜色序列，价值为相同颜色的极大连续段个数，求出最大的价值。 Input 第一行，一个正整数n，一个自然数 m。 接下来m 行，每...
BUAA文本编辑操作模拟（简）a
weixin_45927469的博客
06-28 2496
【问题描述】 编写一程序模拟文本编辑操作。首先从标准输入读取一行字符串（字符个数不超过512），该行字符串是已经过n（大于0，小于等于10）步编辑操作后的结果。然后从下一行读取n，以及已发生过的n步编辑操作，编辑操作分行输入，输入格式为： op pos str 其中op为编辑操作命令编码（在此只有插入和删除操作，1表示插入或2表示删除操作）；pos表示插入或删除的位置；str表示已经插入或删除的字符串（中间没有空格）。各数据间以一个空格分隔。 然后在空一行后，再分行输入当前将要进行的编辑操作，包括如下四种操
jzoj4210. 【五校联考1day1】我才不是萝莉控呢(哈夫曼树)
某司机的黑车
08-23 1358
题意 50分 转换 正解 后记题意有一个(小SB)人要从（n,1）走到（1,1），每次他有两种走法： ①（x−1，y+1）①（x-1，y+1）无损耗 ②⌊（x，（y+1）/2）⌋②⌊（x，（y+1）/2）⌋代价为Σa[i](i=x...n)Σa[i](i=x...n)50分设F[i,j]表示该SB位置为(i,j)，然后转移乱搞N2N^2。转换先引入一个概念。 哈夫曼树 给定n个权值作为
Qt学习之路24--简易文本编辑器--实现可打开、编辑、保存文件操作
热门推荐
一念之间、
09-06 1万+
在前面几节，从学习主窗口QMainWindow开始都是为了简易的文本编辑器的开发，在QMainWindow中学习了菜单栏、状态栏以及工具栏，这正是构成一个简易文本编辑器所需的界面功能。 文本编辑器的主体界面如上，在之前学习QMainWindow时候也完成过部分组件的添加，在私底下我又将其余部分补充到代码里面，最终就形成这样的一个界面，包含菜单栏每个菜单及其快捷方式、工具栏里面的快捷操作，并通...
组合数的性质&证明
某司机的黑车
08-06 4962
组合数
等比数列求和
某司机的黑车
09-06 889
随便口胡
关于最长不下降子序列的优化
某司机的黑车
02-11 774
概念有长度为N的序列: A1 A2 …..An 求最长不下降子序列：Ai1,Ai2,,,,,Aik, 其中ai1<=ai2<=…..<=aik 求最长不下降子序列的长度O(N^2)最容易想到的方法，设F[i]表示以第i位为结尾时最长不下降子序列的长度。 F[i]=max(F[j])+1 (a[i]>=a[j])代码var a:array[1..100] of longint;
用kmp写P2375 [NOI2014] 动物园
最新发布
06-09
虽然 P2375 [NOI2014] 动物园可以转换为字符串匹配问题，但是这种方法不仅会增加代码难度，而且复杂度也会变高，所以不推荐使用。 如果你真的想使用 KMP 算法来解决这个问题，可以将数组 a 和 b 转换为字符串，然后将它们拼接起来，中间用一个分隔符隔开，如 "1 2 3 # 4 5 6 #"。然后，将 b 数组中的元素作为模式串，对该字符串进行 KMP 匹配，匹配到一个 b 数组中的元素时，就说明找到了一组匹配的序列。 但是，这种方法的时间复杂度为 $O(n^2)$，不如动态规划的 $O(n^2)$ 优秀。因此，还是建议使用动态规划来解决 P2375 [NOI2014] 动物园这道题目。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值