BZoj 1500 [NOI2005]维修数列 (Splay 模板)

最新推荐文章于 2016-09-09 21:52:56 发布
最新推荐文章于 2016-09-09 21:52:56 发布
阅读量1.4k 收藏
点赞数
分类专栏： 学习轨迹 数据结构 我的模板 文章标签： Splay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whyorwhnt/article/details/10440115
版权

题目链接：http://61.187.179.132/JudgeOnline/problem.php?id=1500

题意：

题目首先给出一个数列，然后进行下列6种操作
 * 1:INSERT post tot c1,c2,...ctot :在当前数列的第pos个数字后插入tot个数字
 * 2:DELETE pos tot : 从当前数列的第pos个数字开始连续 删除tot个数字
 * 3:MAKE-SAME pos tot c :将当前数列的第pos个数字开始连续的tot个数字统一修改为c
 * 4:REVERSE pos tot : 翻转当前数列的第pos个数字来说的连续的tot个数字
 * 5:GET-SUM pos tot :计算当前数列的第pos个数字来说的连续的tot个数字的和并输出
 * 6：MAX-SUM ：求出当前数列中和最大的一段序列，输出最大和


debug 完这道题之后整个人都斯巴达了。。。。。。。

目测电气自动化专业这学期天书略多。。。。。

Splay最基本的功能这道题基本都包括了，参考了上一篇博文提到的博客。下一题要开始自己想了。

这里有一个别人的模板：

splay 的普通平衡树功能 - 鲜花会有的，AC会有的！ - 博客频道 - CSDN.NET

#include <cstdio>
#include <algorithm>
using namespace std;
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))

#define Key_value ch[ch[root][1]][0] //根节点右孩子的左孩子
#define Key_Value ch[ch[root][1]][0]

const int N=500010;
const int INF=0x3f3f3f3f;
//分别表示父结点,左右孩子(0为左孩子，1为右孩子),键值,结点规模
int pre[N],ch[N][2],key[N],size[N];
//加法延迟标记,翻转延迟标记,最小值
int add[N],rev[N],m[N];
//区间和延迟标记,区间修改相同延迟标记
int sum[N],same[N];
//最大连续和
int lx[N],rx[N],mx[N];
int root,tot1;  //根节点,节点数量
int s[N],tot2;//内存池、内存池容量
int data[N];  //初始数列数组
int n,q;

///   debug  
void Treavel (int x)
{
    if(x)
    {
        Treavel(ch[x][0]);
        printf("结点 %2d:左儿子 %2d 右儿子 %2d  父结点 %2d key=%2d,size=%2d,rev=%2d\n",x,ch[x][0],ch[x][1],pre[x],key[x],size[x],rev[x]);
        Treavel(ch[x][1]);
    }
}
void debug ()
{
    printf("root:%d\n",root);
    Treavel(root);
}
/

void NewNode (int &r,int father,int k)
{
    if (tot2)r=s[tot2--];
    else r=++tot1;
    ch[r][0]=ch[r][1]=0;
    pre[r]=father;
    size[r]=1;
	sum[r]=k;
	same[r]=0;
    add[r]=rev[r]=0;
    key[r]=m[r]=k;
	lx[r]=rx[r]=mx[r]=k;
}
void Update_Rev (int r)  //更新r节点的翻转值
{
    if(!r)return;
    swap(ch[r][0],ch[r][1]);
	swap(lx[r],rx[r]);        注意这里,记得交换
    rev[r]^=1;
}
void Update_Same (int r,int v)
{
    if(!r)return;
    key[r]=v;
    sum[r]=v*size[r];
    lx[r]=rx[r]=mx[r]=max(v,v*size[r]);
    same[r]=1;
}

void Update_Add (int r,int ADD) //更新r节点的加法值
{
    if(!r)return;
    add[r]+=ADD;
    key[r]+=ADD;
    m[r]+=ADD;
}

void Push_Up (int r) //向上更新,由r节点的儿子更新r节点
{
    size[r]=size[ch[r][0]]+size[ch[r][1]]+1;
	//更新最小值
    m[r]=key[r];
    if(ch[r][0])m[r]=min(m[r],m[ch[r][0]]);
    if(ch[r][1])m[r]=min(m[r],m[ch[r][1]]);
	//更新和及最大连续和
	int lson=ch[r][0],rson=ch[r][1];
    sum[r]=sum[lson]+sum[rson]+key[r];
    lx[r]=max(lx[lson],sum[lson]+key[r]+max(0,lx[rson]));
    rx[r]=max(rx[rson],sum[rson]+key[r]+max(0,rx[lson]));
    mx[r]=max(0,rx[lson])+key[r]+max(0,lx[rson]);
    mx[r]=max(mx[r],max(mx[lson],mx[rson]));
}
void Push_Down (int r)  //向下更新,由r节点更新其儿子节点
{
	if (same[r])
	{
		Update_Same(ch[r][0],key[r]);
		Update_Same(ch[r][1],key[r]);
		same[r]=0;
	}
    if (rev[r])
    {
        Update_Rev(ch[r][0]);
        Update_Rev(ch[r][1]);
        rev[r]=0;
    }
    if (add[r])
    {
        Update_Add(ch[r][0],add[r]);
        Update_Add(ch[r][1],add[r]);
        add[r]=0;
    }
	
}

void Build (int &x,int l,int r,int father)
{//利用数组data建树,data从1开始,有n个元素
//调用格式 Build(Key_value,1,n,ch[root][1]);
    if (l>r) return;
    int mid=(l+r)>>1;
    NewNode(x,father,data[mid]);
    Build(ch[x][0],l,mid-1,x);
    Build(ch[x][1],mid+1,r,x);
    Push_Up(x);
}

void Init ()
{//Splay初始化
    root=tot1=tot2=0;
    ch[root][0]=ch[root][1]=size[root]=pre[root]=key[root]=0;
	add[root]=rev[root]=sum[root]=same[root]=0;
	lx[root]=rx[root]=mx[root]=-INF;
    m[root]=INF;//这个不用也可以,如果在push_up那判断了的话，否则需要
	///视求最大最小值修改///
	NewNode(root,0,-1);
	NewNode(ch[root][1],root,-1);
	
	NewNode(root,0,INF);
	NewNode(ch[root][1],root,INF);  
}

void Init_Array ()
{
	for (int i=1;i<=n;i++) scanf("%d",&data[i]);
	Init ();
	Build(Key_value,1,n,ch[root][1]);
	Push_Up(ch[root][1]);
	Push_Up(root);
}

void Rotate (int x,int kind)
{//旋转
    int y=pre[x];
    Push_Down(y);
    Push_Down(x);
    ch[y][!kind]=ch[x][kind];
    pre[ch[x][kind]]=y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y]=x;
    pre[x]=pre[y];
    ch[x][kind]=y;
    pre[y]=x;
    Push_Up(y);
}

void Splay (int r,int goal) 
{//Splay调整,将第r节点调整到goal位置
	
    Push_Down(r);
    while (pre[r]!=goal)
    {
        if (pre[pre[r]]==goal)
        {
            //这题有反转操作，需要先push_down,再判断左右孩子
            Push_Down(pre[r]);
            Push_Down(r);
            Rotate(r,ch[pre[r]][0]==r);
        }

        else
        {
            //这题有反转操作，需要先push_down,再判断左右孩子
            Push_Down(pre[pre[r]]);
            Push_Down(pre[r]);
            Push_Down(r);//printf("nani?\n");
            int y=pre[r];
            int kind=(ch[pre[y]][0]==y);
            //两个方向不同，则先左旋再右旋
            if (ch[y][kind]==r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            //两个方向相同，相同方向连续两次
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    Push_Up(r);
	//更新根节点
    if(goal==0)root=r;
}

int Get_Kth (int r,int k)   //找第k个节点
{
    Push_Down(r);
    int t=size[ch[r][0]]+1;
    if(t==k)return r;
    if(t>k)return Get_Kth(ch[r][0],k);
    else return Get_Kth(ch[r][1],k-t);
}

int Get_Min (int r)
{
    Push_Down(r);
    while (ch[r][0])
    {
        r=ch[r][0];
        Push_Down(r);
    }
    return r;
}

int Get_Max (int r)
{
    Push_Down (r);
    while (ch[r][1])
    {
        r=ch[r][1];
        Push_Down(r);
    }
    return r;
}

//下面是操作了

void Add (int l,int r,int D)
{//区间l到r全部加D
    Splay(Get_Kth(root,l),0);
    Splay(Get_Kth(root,r+2),root);
    Update_Add(Key_value,D);
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void Reverse (int l,int r)
{//区间l到r全部翻转
    Splay(Get_Kth(root,l),0);
    Splay(Get_Kth(root,r+2),root);
    Update_Rev(Key_value);
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void Revolve (int l,int r,int T)
{//循环右移T长度,其实就是交换区间
    int len=r-l+1;
    T=(T%len+len)%len;
    if (T==0)return;
    int c=r-T+1;//将区间[c,r]放在[l,c-1]前面
    Splay(Get_Kth(root,c),0);
    Splay(Get_Kth(root,r+2),root);
    int tmp=Key_value;
    Key_value=0;   //此时已将区间拆下
    Push_Up(ch[root][1]);  //拆下后记得更新
    Push_Up(root);
    Splay(Get_Kth(root,l),0);
    Splay(Get_Kth(root,l+1),root);  //放在l之前
    Key_value=tmp;
    pre[Key_value]=ch[root][1];//这个不要忘记
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void Insert (int x,int P)
{//在第x个数后面插入P
    Splay(Get_Kth(root,x+1),0);
    Splay(Get_Kth(root,x+2),root);
    NewNode(Key_value,ch[root][1],P);
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void Insert_Array (int pos,int tot)
{//在第pos个数后插入tot个数
    for (int i=0;i<tot;i++)
		scanf("%d",&data[i]);
    Splay(Get_Kth(root,pos+1),0);
    Splay(Get_Kth(root,pos+2),root);
    Build(Key_value,0,tot-1,ch[root][1]);
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void erase (int r)
{//回收内存
    if(r)
    {
        s[++tot2]=r;
        erase(ch[r][0]);
        erase(ch[r][1]);
    }
}

void Delete (int x)
{//删除第x个数
    Splay(Get_Kth(root,x),0);
    Splay(Get_Kth(root,x+2),root);
    erase(Key_value);
    pre[Key_value]=0;
    Key_value=0;
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void Delete_Array (int pos,int tot)
{//从第pos个数开始连续删除tot个数
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);
    erase(Key_value);
    pre[Key_value]=0;
    Key_value=0;
    Push_Up(ch[root][1]);
    Push_Up(root);
}

void Make_Same (int pos,int tot,int c)
{//从第pos个数连续开始的tot个数修改为c
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);
    Update_Same(Key_value,c);
    Push_Up(ch[root][1]);
    Push_Up(root);
}

int Get_Sum (int pos,int tot)
{//求和
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);
    return sum[Key_value];
}

int Get_MaxSum (int pos,int tot)
{//从pos开始连续tot个数中最大连续和
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);
    return mx[Key_value];
}

int Query_Min (int l,int r)
{//查找区间最小
    Splay(Get_Kth(root,l),0);
    Splay(Get_Kth(root,r+2),root);
    return m[Key_value];
} 

int cnt=0;  //中序遍历输出,每次遍历之后需要将cnt置0
//注意该函数需要知道数据规模,既全局变量n
void Inorder (int r)   
{
	if (!r) return;
	Push_Down(r);
	Inorder(ch[r][0]);
	if (cnt>=1 && cnt<=n)
		printf(cnt<n?"%d ":"%d\n",key[r]);
	cnt++;
	Inorder (ch[r][1]);
}

char str[20];

int main ()
{  
#ifdef ONLINE_JUDGE
#else
	freopen("read.txt","r",stdin);
#endif
	int m;
	while (~scanf("%d%d",&n,&m))
	{
		Init_Array ();
		while (m--)
		{
			int x,y,z;
			scanf("%s",str);    
			switch (str[2])  
			{  
			case 'S':  
				scanf("%d%d", &x,&y);  
				Insert_Array(x,y);
				break;  
			case 'L':    
				scanf("%d%d", &x,&y);
				Delete_Array(x,y);
				break;
			case 'K':
				scanf("%d%d%d", &x,&y,&z);
				Make_Same(x,y,z);
				
				break;
			case 'V':     
                scanf("%d%d", &x,&y);  
                Reverse(x,x+y-1);
				break;
			case 'T':
				scanf("%d%d", &x,&y);
				printf("%d\n",Get_Sum(x,y));
				break;
			case 'X':
				printf("%d\n",Get_MaxSum(1,size[root]-2));
			}
		}
	}
	return 0;
}


时雨晴天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 4441 Queue Sequence（12年天津现场，Splay+线段树）
窝不是爱酱,喵~~~~
10-28 4178
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents    by---cxlove  题目：每次有三种操作 insert pos  表示在pos插入一个数，这个数是最小的正数没有在序列中出现的。而且还要在某个位置插入他的相反数 remove num 表示把num以及-num去掉 query num 把num与-num之间
BZOJ 1500[NOI2005] 维修数列
Time_major
03-30 433
Description解题思路： 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻数列中最多含有500 000个数，数列中任何一个数字均在[-1 000, 1 000]内。 插入的数字总数不超过4 000 000个，输入
知道了内存池的作用...poj3580
blog
09-09 257
#include #include #include #include using namespace std; #define Key_value ch[ch[root][1]][0] const int MAXN=200010; const int INF=0x3f3f3f3f; int pre[MAXN],ch[MAXN][2],key[MAXN],size[MAXN],add[MAXN],
BZOJ 1500 NOI2005 维修数列 Splay
世界
09-18 1834
我尽力了。。。从之前的递归版Splay变成非递归，然后各种删除冗余的操作，除了蛋疼的读入优化基本已经精简到底了，连传参都省了-0- 刚交上去是10956MS，差4MS就是BZOJ倒数第一，改完了是9244MS，快了一秒。。。单点测还是死活过不去，等加上读入优化再说吧 题目大意：维护一个序列，支持六种操作： 1.在某个数后面插入一些数字 2.删除从某个数开始的一些数字 3.把从某个数开始的一
[BZOJ1500]NOI2005 维修数列|splay
Tag_king的专栏
04-18 1821
这题号称是noi出过最变态的数据结构题，，感觉还差不多嘛。。一开始我一直在纠结splay上的节点一点要有一个key值的啊，要是以这个数在序列中的位置作为key值的话又要插入又要删除肯定弄不了。。然后想了很久突然顿悟。。貌似我给一个初始顺序以后是不用访问key的&&找第k位的数只要写一个findkth就行了嘛。。（当时太弱） 然后我就一口气写了下来。。 对每个节点维护size，sum，maxsu
陈立杰历年课件和BZOJ代码
12-04
【陈立杰历年课件和BZOJ代码】是一个集合，包含了知名算法竞赛选手陈立杰（WJMZBMR）在过去的时间里所使用的课件以及他在BZOJ（Best Wrong Judge Online Judge）平台上提交的大部分代码。这个资源对于学习算法、C++...
bzoj测试数据118题数据
05-07
八中OJ,又简作BZOJ,以原题巨多而著称，该数据为BZOJ上的1000-1109和1130-1139的测试数据节点，没有题目，有需要题目的可以到https://hydro.ac/d/bzoj/p网站查找对应的题目。
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
Poj 1986 Distance Queries (LCA 树上两点间最短距离)
whyorwhnt的专栏
02-06 2423
题意：给出n个点和m条边，再给出K个询问，询问x和y点的树上最短距离 本题貌似在线算法快很多，282ms，离线算法1360ms，个人还是觉得在线算法好理解些。 #include #include #include const int N=40005; struct node { int v,dis,next; }edges[N<<1]; int head[N],e; int pre
BZOJ 1878 【SDOI2009】HH的项链（离线+树状数组）
whyorwhnt的专栏
07-11 2016
题目链接：http://61.187.179.132/JudgeOnline/problem.php?id=1878 思路：参考了http://blog.csdn.net/njlcazl/article/details/8758443 下面加一些自己的理解： 因为操作中只有询问没有更新，所以可以使用离线算法，对所有询问按右区间升序排序。 以该数字第一次在区间中出现的点代表所有的点。如果是第
Poj 1635 Subway tree systems （树的最小表示）
whyorwhnt的专栏
07-17 1759
题目链接：http://poj.org/problem?id=1635 题意：初始时站在树的根节点，若朝着远离根的方向走，记录“0”，接近根的方向走记录“1”。并且树的每一条边只能来回走一次（即向下和返回）。一个合法的01序列可以描述出一棵树的形态。现在给出两个合法的01序列，判断两棵树是否同构。 思路主要参考了这里：http://blog.csdn.net/tiaotiaoyly/artic
单调队列学习小记 Poj 2823 + Hdu 3530 (deque)
whyorwhnt的专栏
06-17 1732
以前学过的东西，拿出来复习下。 poj2823 单调队列（含单调队列的学习） - Jason Damon博客园 http://www.cnblogs.com/Jason-Damon/archive/2012/04/19/2457889.html 单调队列 - Hackbuteer1的专栏 - 博客频道 - CSDN.NET http://blog.csdn.net/hackbuteer
携程第二场 Poj 1182 食物链(带权并查集) Poj 1948 Triangular Pastures Poj（dp二维背包） 1740 A New Stone Game（博弈）
whyorwhnt的专栏
04-11 1726
携程的第二场好多原题，网上好多题解。。。
单调队列及其deque写法 HDU 3415+Poj 4002 (日期处理) + 合并果子
whyorwhnt的专栏
02-02 1664
尝试用deque写一下单调队列，发现速度还是可以接受的，STL依赖症越来越严重了。。。。 HDU 3415 Max Sum of Max-K-sub-sequence 题意：给出一个有N个数字（-1000..1000，N #include #include #include using namespace std; #define upmax(a,b) ((a)=(a)>(b)
线段树区间染色 浮水法 学习小记 Poj 2777 + Poj 2528
whyorwhnt的专栏
05-14 1603
复习过的东西必须时常拿来练练，虽说都是水题。。。。 Poj 2777 典型的区间染色问题，貌似我的写法为了不数组越界必须多开一倍的数组空间。。。。。还没有想到解决方法，有机会参考一下别人的写法。 Poj 2528 和上面那道差不多，用线段树写的时候用了STL里的map进行离散化，因为不可能开出10000000*4大小的数组。 我的代码在poj过不了，看discuss里面有人说测试数据有问题…
福州大学第十一届程序设计竞赛 部分题目题解
whyorwhnt的专栏
04-27 1557
比赛链接：http://acm.fzu.edu.cn/contest/index.php?cid=139 当今天下午我知道有这个比赛的时候
图论精华：从基础到进阶的NOI图论教程
"这是关于NOI（全国青少年信息学奥林匹克竞赛）图论知识的全面总结，适合不同程度的选手学习，从基础到高级逐步深入。内容涵盖了图的分类、基础图论概念、进阶图论技巧以及相关算法应用。" 在NOI的图论学习中，首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值