bzoj P4825 [Hnoi2017]单旋——solution

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

　　　　　　　　　　　　　　　　　　　　　　　　　　——by bzoj

http://www.lydsy.com/JudgeOnline/problem.php?id=4825

---

---

这个bzoj的蓝底好赞啊

 

如果是双旋splay，就是模板题；

然而是单旋splay，

直接模拟？

亲测洛谷t成暴力分（废话，本来就是暴力）

可能出题人刻意卡了，也可能本来就非常好卡

 

考虑尝试其他方法；

 

-操作1 k：      找到k的前驱，后继，如果当前树上前驱无右子节点，则k代表的点挂在前驱右子节点的位置，否则挂在后继的左子节点处

　　　　　　可以证明前驱的右子节点与后继的左子节点至少有一个不存在；

（因为在k加入集合之前，集合中不存在大小在k的前驱和后继间的元素，于是若k的前驱有右子树，则k的后继必在此子树上）

（否则这棵子树上的所有点都在k的前驱后继之间）

（既然k的后继在k的前驱的右子树上，那么他的左子树上所有元素都在k的前驱后继之间，于是他没有左子节点）

-操作2和3：   观察单旋最小值或最大值的过程，发现此过程对树的结构影响极少，

　　　　　　只是把这个代表最大|小值的节点剥离树，

　　　　　　他的子节点接替他做父节点的子节点(他只有一个子节点)，

　　　　　　然后把剩余整个树挂在他的左|右子树位置，

-操作4和5：   相当于操作2和3省去最后一个过程，然后保留剩下的树，而把剥离的点弃置

 

维护树的结构的部分可以直接用LCT；

查找加入节点的位置——即找前驱后继可以直接用MAP实现

代码：

（又一次证明了我的代码能力和STL能力有多烂）

（LCT的写法有点奇怪……不支持换根的写法）

 #include<map>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 map<int ,int > MAP;
 int m,top;
 struct DT{
     int ch[],CH[],fa,FA;
     int size,num;
 };
 struct Splay{
     DT data[];
     void splay(int x){
         int fa,fafa;
         for(fa=data[x].fa;che(x);roll(x),fa=data[x].fa){
             fafa=data[fa].fa;
             if(che(fa)){
                 if((data[fa].ch[]==x)^(data[fafa].ch[]==fa))
                     roll(x);
                 else
                     roll(fa);
             }
         }
     }
     void roll(int x){
         int fa=data[x].fa,fafa=data[fa].fa,wh=data[fa].ch[]==x;
         data[fa].ch[wh]=data[x].ch[wh^],data[data[fa].ch[wh]].fa=fa;
         data[fa].fa=x,data[x].ch[wh^]=fa;
         data[x].fa=fafa;
         if(data[fafa].ch[]==fa||data[fafa].ch[]==fa)
             data[fafa].ch[data[fafa].ch[]==fa]=x;
         up(fa),up(x);
     }
     bool che(int x){
         return data[data[x].fa].ch[]==x||data[data[x].fa].ch[]==x;
     }
     void up(int x){
         data[x].size=data[data[x].ch[]].size+data[data[x].ch[]].size+;
     }
 };
 struct LCT{
     Splay T;
     int root;
     void Mak_data(int id,int num){
         T.data[id].ch[]=T.data[id].ch[]=T.data[id].CH[]=T.data[id].CH[]=;
         T.data[id].FA=T.data[id].fa=;
         T.data[id].size=,T.data[id].num=num;
     }
     void Link(int fa,int son,int wh){
         Access(son),T.splay(son);
         T.data[son].FA=fa;
         T.data[son].fa=fa;
         T.data[fa].CH[wh]=son;
         Access(son);
     }
     void Cut(int fa,int son){
         Access(fa),T.splay(son);
         T.data[son].FA=T.data[son].fa=;
         T.data[fa].CH[T.data[fa].CH[]==son]=;
     }
     void Access(int x){
         int y=;
         while(x){
             T.splay(x);
             T.data[x].ch[]=y,T.up(x);
             y=x,x=T.data[x].fa;
         }
     }
 };
 LCT lct;
 inline void in(int &ans)
 {
     ans=;bool p=false;char ch=getchar();
     while((ch>'' || ch<'')&&ch!='-') ch=getchar();
     if(ch=='-') p=true,ch=getchar();
     while(ch<=''&&ch>='') ans=ans*+ch-'',ch=getchar();
     if(p) ans=-ans;
 }
 int main()
 {
     int i,j,k,templ,tempr,temp,f,c;
     map<int ,int >::iterator iter;
     in(m);
     lct.root=;
     for(i=;i<=m;i++){
         in(j);
         if(j==){
             in(k);
             lct.Mak_data(++top,k);
             if(lct.root){
                 iter=MAP.upper_bound(k);
                 tempr=iter->second,templ=;
                 if(iter!=MAP.begin())iter--,templ=iter->second;
                 if(templ&&!lct.T.data[templ].CH[])
                     lct.Link(templ,top,);
                 else
                     lct.Link(tempr,top,);
             }
             else
                 lct.root=top;
             lct.Access(top),lct.T.splay(top);
             printf("%d\n",lct.T.data[top].size);
             MAP[k]=top;
         }
         else{
             iter=MAP.end(),iter--;
             if(j&)
                 temp=iter->second;
             else
                 temp=MAP.begin()->second;
             lct.Access(temp),lct.T.splay(temp);
             printf("%d\n",lct.T.data[temp].size);
             if(lct.T.data[temp].FA&&lct.T.data[temp].CH[!(j&)]){
                 f=lct.T.data[temp].FA,c=lct.T.data[temp].CH[!(j&)];
                 lct.Cut(temp,c),lct.Cut(f,temp);
                 lct.Link(f,c,j&);
             }
             else{
                 if(lct.T.data[temp].FA||lct.T.data[temp].CH[!(j&)])
                     if(lct.T.data[temp].FA)
                         lct.Cut(lct.T.data[temp].FA,temp);
                     else
                         lct.root=lct.T.data[temp].CH[!(j&)],lct.Cut(temp,lct.T.data[temp].CH[!(j&)]);
                 else{
                     if(j>)
                         lct.root=,MAP.erase(lct.T.data[temp].num);
                     continue;
                 }
             }
             if(j<)
                 lct.Link(temp,lct.root,!(j&)),lct.root=temp;
             else
                 MAP.erase(lct.T.data[temp].num);
         }
     }
 }