【刷题】BZOJ 4825 [Hnoi2017]单旋

Description

H 国是一个热爱写代码的国家，那里的人们很小去学校学习写各种各样的数据结构。伸展树（splay）是一种数据结构，因为代码好写，功能多，效率高，掌握这种数据结构成为了 H 国的必修技能。有一天，邪恶的“卡”带着他的邪恶的“常数”来企图毁灭 H 国。“卡”给 H 国的人洗脑说，splay 如果写成单旋的，将会更快。“卡”称“单旋 splay”为“spaly”。虽说他说的很没道理，但还是有 H 国的人相信了，小 H 就是其中之一，spaly 马上成为他的信仰。 而 H 国的国王，自然不允许这样的风气蔓延，国王构造了一组数据，数据由 m 个操作构成，他知道这样的数据肯定打垮 spaly，但是国王还有很多很多其他的事情要做，所以统计每个操作所需要的实际代价的任务就交给你啦。

数据中的操作分为五种：

1. 插入操作：向当前非空 spaly 中插入一个关键码为 key 的新孤立节点。插入方法为，先让 key 和根比较，如果key 比根小，则往左子树走，否则往右子树走，如此反复，直到某个时刻，key 比当前子树根 x 小，而 x 的左子树为空，那就让 key 成为 x 的左孩子； 或者 key 比当前子树根 x 大，而 x 的右子树为空，那就让 key 成为x 的右孩子。该操作的代价为：插入后，key 的深度。特别地，若树为空，则直接让新节点成为一个单个节点的树。（各节点关键码互不相等。对于“深度”的解释见末尾对 spaly 的描述）。

2. 单旋最小值：将 spaly 中关键码最小的元素 xmin 单旋到根。操作代价为：单旋前 xmin 的深度。（对于单旋操作的解释见末尾对 spaly 的描述）。

3. 单旋最大值：将 spaly 中关键码最大的元素 xmax 单旋到根。操作代价为：单旋前 xmax 的深度。

4. 单旋删除最小值：先执行 2 号操作,然后把根删除。由于 2 号操作之后,根没有左子树,所以直接切断根和右子树的联系即可（具体见样例解释）。 操作代价同 2 号操 作。

5. 单旋删除最大值：先执行 3 号操作,然后把根删除。 操作代价同 3 号操作。

对于不是 H 国的人，你可能需要了解一些 spaly 的知识，才能完成国王的任务：

a. spaly 是一棵二叉树，满足对于任意一个节点 x，它如果有左孩子 lx，那么 lx 的关键码小于 x 的关键码。如果有右孩子 rx，那么 rx 的关键码大于 x 的关键码。

b. 一个节点在 spaly 的深度定义为：从根节点到该节点的路径上一共有多少个节点（包括自己）。

c. 单旋操作是对于一棵树上的节点 x 来说的。一开始,设 f 为 x 在树上的父亲。如果 x 为 f 的左孩子，那么执行 zig(x) 操作（如上图中，左边的树经过 zig(x) 变为了右边的树），否则执行 zag(x) 操作（在上图中，将右边的树经过 zag(f) 就变成了左边的树）。每当执 行一次 zig(x) 或者 zag(x)，x 的深度减小 1，如此反复，直到 x 为根。总之，单旋 x 就是通过反复执行 zig 和 zag 将 x 变为根。

Input

第一行单独一个正整数 m。

接下来 m 行，每行描述一个操作：首先是一个操作编号 c∈[1,5]，即问题描述中给出的五种操作中的编号，若 c = 1，则再输入一个非负整数 key，表示新插入节点的关键码。

1≤m≤10^{5,1≤key≤10}9

所有出现的关键码互不相同。任何一个非插入操作，一定保证树非空。在未执行任何操作之前，树为空

Output

输出共 m 行，每行一个整数，第 i 行对应第 i 个输入的操作的代价。

Sample Input

5

1 2

1 1

1 3

4

5

Sample Output

1

2

2

2

2

Solution

题目看了很久

操作一个一个看

第一个：对于一个splay，如果我们有一个它的中序遍历的数组，那么新插一个数，这个数要么是在数组的最前面或最后面（这种情况特判掉，不在后面的考虑范围），要么就一定被夹在数组中相邻两个数中间没，称前面那个数为前驱，后面的为后继，所以新插的这个数，要么是前驱的右儿子，要么是后继的左儿子；然后就一个性质，前驱的右儿子和后继的左儿子恰好有且仅有一个位置是空的，为什么？反证，考虑如果两个位置都是空的，但前驱和后继肯定有一个共同的祖先，而这个祖先根据中序遍历，在中序遍历的数组中会夹在前驱和后继中间，这样前驱后继不相邻，就不是新插数的前驱和后继了。然后有着这个性质，就只要快速找到它的前驱和后继，判断插在哪个位置就行了。这个中序遍历的数组可以用set维护，而找位置，upper_bound就可以了

第二/三个：手动画几个树，旋一下，会发现，由于修改的只是两个最值，最左边的和最右边的，最后的形状是差不多的，对于Mn，就是它的右儿子代替自己的位置，它变成了根，对于Mx，就是它的左儿子代替自己的位置，它变成了根，直接 \(O(1)\) 修改就行了

第四/五个：既然已经知道怎么旋到根了，那到根之后就直接删掉就好了

操作搞定了，然后想怎么维护答案

可以用一个LCT直接维护，然后一个点的深度就是它与根access后，根的size

所以这题两个东西

一个LCT，维护每个点的深度

一个Spaly，题目中说的东西，但不要暴力维护，按照上面的方法修改，只要记录父亲，左右儿子，中序遍历的序列，顺便再离散化一下就行了

#include<bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define db double
#define ld long double
#define ull unsigned long long
const int MAXN=100000+10;
int m;
#define lc(x) ch[(x)][0]
#define rc(x) ch[(x)][1]
struct LCT{
	int ch[MAXN][2],fa[MAXN],rev[MAXN],size[MAXN],stack[MAXN],cnt;
	inline bool nroot(int x)
	{
		return lc(fa[x])==x||rc(fa[x])==x;
	}
	inline void reverse(int x)
	{
		std::swap(lc(x),rc(x));
		rev[x]^=1;
	}
	inline void pushup(int x)
	{
		size[x]=size[lc(x)]+size[rc(x)]+1;
	}
	inline void pushdown(int x)
	{
		if(rev[x])
		{
			if(lc(x))reverse(lc(x));
			if(rc(x))reverse(rc(x));
			rev[x]=0;
		}
	}
	inline void rotate(int x)
	{
		int f=fa[x],p=fa[f],c=(rc(f)==x);
		if(nroot(f))ch[p][rc(p)==f]=x;
		fa[ch[f][c]=ch[x][c^1]]=f;
		fa[ch[x][c^1]=f]=x;
		fa[x]=p;
		pushup(f);
		pushup(x);
	}
	inline void splay(int x)
	{
		cnt=0;
		stack[++cnt]=x;
		for(register int i=x;nroot(i);i=fa[i])stack[++cnt]=fa[i];
		while(cnt)pushdown(stack[cnt--]);
		for(register int y=fa[x];nroot(x);rotate(x),y=fa[x])
			if(nroot(y))rotate((lc(y)==x)==(lc(fa[y])==y)?y:x);
		pushup(x);
	}
	inline void access(int x)
	{
		for(register int y=0;x;x=fa[y=x])splay(x),rc(x)=y,pushup(x);
	}
	inline void makeroot(int x)
	{
		access(x);splay(x);reverse(x);
	}
	inline void split(int x,int y)
	{
		makeroot(x);access(y);splay(y);
	}
	inline void link(int x,int y)
	{
		makeroot(x);fa[x]=y;
	}
	inline void cut(int x,int y)
	{
		split(x,y);fa[x]=lc(y)=0;pushup(y);
	}
};
LCT T;
#undef lc
#undef rc
template<typename T> inline void read(T &x)
{
	T data=0,w=1;
	char ch=0;
	while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
	if(ch=='-')w=-1,ch=getchar();
	while(ch>='0'&&ch<='9')data=((T)data<<3)+((T)data<<1)+(ch^'0'),ch=getchar();
	x=data*w;
}
template<typename T> inline void write(T x,char c='\0')
{
	if(x<0)putchar('-'),x=-x;
	if(x>9)write(x/10);
	putchar(x%10+'0');
	if(c!='\0')putchar(c);
}
struct Spaly{
	int root,fa[MAXN],ls[MAXN],rs[MAXN],size;
	std::set<int> S;
	std::map<int,int> M;
	inline void init()
	{
		root=0;
		memset(fa,0,sizeof(fa));
		memset(ls,0,sizeof(ls));
		memset(rs,0,sizeof(rs));
	}
	inline void Insert(int x)
	{
		M[x]=++size;
		if(!root)
		{
			root=M[x],write(1,'\n'),S.insert(x);
			return ;
		}
		std::set<int>::iterator it=S.upper_bound(x);
		if(it==S.end()||ls[M[*it]])--it,T.link(M[*it],M[x]),fa[M[x]]=M[*it],rs[M[*it]]=M[x];
		else T.link(M[*it],M[x]),fa[M[x]]=M[*it],ls[M[*it]]=M[x];
		S.insert(x);
		T.split(M[x],root);
		write(T.size[root],'\n');
	}
	inline void Mnrotate()
	{
		int x=M[*S.begin()];
		if(x==root)
		{
			write(1,'\n');
			return ;
		}
		T.split(x,root);
		write(T.size[root],'\n');
		T.cut(x,fa[x]);
		if(rs[x])T.cut(x,rs[x]),T.link(rs[x],fa[x]);
		T.link(root,x);
		fa[rs[x]]=fa[x];ls[fa[x]]=rs[x];fa[root]=x;rs[x]=root;fa[x]=0;
		root=x;
	}
	inline void Mxrotate()
	{
		int x=M[*--S.end()];
		if(x==root)
		{
			write(1,'\n');
			return ;
		}
		T.split(x,root);
		write(T.size[root],'\n');
		T.cut(x,fa[x]);
		if(ls[x])T.cut(x,ls[x]),T.link(ls[x],fa[x]);
		T.link(root,x);
		fa[ls[x]]=fa[x];rs[fa[x]]=ls[x];fa[root]=x;ls[x]=root;fa[x]=0;
		root=x;
	}
	inline void Mndelete()
	{
		int x=M[*S.begin()];
		if(x==root)
		{
			if(rs[x])T.cut(x,rs[x]);
			fa[rs[x]]=0;root=rs[x];
			S.erase(S.begin());
			write(1,'\n');
			return ;
		}
		T.split(x,root);
		write(T.size[root],'\n');
		T.cut(x,fa[x]);
		if(rs[x])T.cut(x,rs[x]),T.link(rs[x],fa[x]);
		fa[rs[x]]=fa[x];ls[fa[x]]=rs[x];
		S.erase(S.begin());
	}
	inline void Mxdelete()
	{
		int x=M[*--S.end()];
		if(x==root)
		{
			if(ls[x])T.cut(x,ls[x]);
			fa[ls[x]]=0;root=ls[x];
			S.erase(--S.end());
			write(1,'\n');
			return ;
		}
		T.split(x,root);
		write(T.size[root],'\n');
		T.cut(x,fa[x]);
		if(ls[x])T.cut(x,ls[x]),T.link(ls[x],fa[x]);
		fa[ls[x]]=fa[x];rs[fa[x]]=ls[x];
		S.erase(--S.end());
	}
};
Spaly ST;
template<typename T> inline void chkmin(T &x,T y){x=(y<x?y:x);}
template<typename T> inline void chkmax(T &x,T y){x=(y>x?y:x);}
template<typename T> inline T min(T x,T y){return x<y?x:y;}
template<typename T> inline T max(T x,T y){return x>y?x:y;}
int main()
{
	read(m);
	ST.init();
	int opt,x;
	while(m--)
	{
		read(opt);
		if(opt==1)read(x),ST.Insert(x);
		if(opt==2)ST.Mnrotate();
		if(opt==3)ST.Mxrotate();
		if(opt==4)ST.Mndelete();
		if(opt==5)ST.Mxdelete();
	}
	return 0;
}