[bzoj4825] [loj#2018] [Hnoi2017] 单旋

Description

$H$ 国是一个热爱写代码的国家，那里的人们很小去学校学习写各种各样的数据结构。伸展树（$splay$）是一种数据

结构，因为代码好写，功能多，效率高，掌握这种数据结构成为了 $H$ 国的必修技能。有一天，邪恶的“卡”带着

他的邪恶的“常数”来企图毁灭 $H$ 国。“卡”给 $H$ 国的人洗脑说，$splay$ 如果写成单旋的，将会更快。“卡”称

“单旋 $splay$ ”为“ $spaly$ ”。虽说他说的很没道理，但还是有 $H$ 国的人相信了，小 $H$ 就是其中之一，$spaly$ 马

上成为他的信仰。而 $H$ 国的国王，自然不允许这样的风气蔓延，国王构造了一组数据，数据由 $m$ 个操作构成，

他知道这样的数据肯定打垮 $spaly$，但是国王还有很多很多其他的事情要做，所以统计每个操作所需要的实际代价

的任务就交给你啦。

数据中的操作分为五种：

插入操作：向当前非空 $spaly$ 中插入一个关键码为 $key$ 的新孤立节点。插入方法为，先让 $key$ 和根比较，如果

$key$ 比根小，则往左子树走，否则往右子树走，如此反复，直到某个时刻，$key$ 比当前子树根 $x$ 小，而 $x$ 的左子

树为空，那就让 $key$ 成为 $x$ 的左孩子；或者 $key$ 比当前子树根 $x$ 大，而 $x$ 的右子树为空，那就让 $key$ 成为

$x$ 的右孩子。该操作的代价为：插入后，$key$ 的深度。特别地，若树为空，则直接让新节点成为一个单个节点的树

。（各节点关键码互不相等。对于“深度”的解释见末尾对 $spaly$ 的描述）。
单旋最小值：将 $spaly$ 中关键码最小的元素 $xmin$ 单旋到根。操作代价为：单旋前 $xmin$ 的深度。

（对于单旋操作的解释见末尾对 $spaly$ 的描述）。
单旋最大值：将 $spaly$ 中关键码最大的元素 $xmax$ 单旋到根。操作代价为：单旋前 $xmax$ 的深度。
单旋删除最小值：先执行 2 号操作,然后把根删除。由于 2 号操作之后,根没有左子树,所以直接切断根和右子

树的联系即可（具体见样例解释）。操作代价同 2 号操作。
单旋删除最大值：先执行 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 \in [1,5]$，即问题描述中给出的五种操作中的编号，若 $c
= 1$，则再输入一个非负整数 $key$，表示新插入节点的关键码。

$1 \leq m \leq 10^5,1 \leq key \leq 10^9$

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

Output

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

Sample Input

1 2

1 1

1 3

Sample Output

想法

首先发现，所有旋转上去的点要么最大要么最小，那么只会一直左旋或右旋

之后手玩几组发现，转上去后，有变化的只是它的子节点接到了它的父节点上，原本的根节点接到了它下面，其他的相对顺序都没变

那么这道题让我们维护的深度很好搞，就是它原本子节点的深度不变，它的深度变成1，其它点深度都+1

而对于删除根节点，深度也很好维护，就是所有点深度-1

接着考虑插入节点是怎么知道它应插到哪里。

继续画一画发现，我们可以维护每个节点直接相连有几个可以插新节点的位置（0或1或2），假设原本树上有 $x$ 个点比我们要插的点小，那么新点就应插在第 $x+1$ 个空位上。它的深度就是它父节点深度+1，我们在找空位的时候就能知道它的父节点是谁。

先把所有数据都进来，离散化一下。

线段树维护深度和空位数和某一个区间内在树中的节点数。

最大值/最小值怎么搞？可以用个 $set$ 维护当前树中的点。

嗯，口胡地差不多了，感觉不太难。

写起来，啊啊啊啊啊怎么这么多细节啊啊啊啊啊！多多多多多多注意下。。。

挺好也挺毒瘤的一道题。

代码

啊，191行的代码

#include<cstdio>

#include<iostream>

#include<algorithm>

#include<set>

using namespace std;

int read(){

    int x=0;

    char ch=getchar();

    while(!isdigit(ch)) ch=getchar();

    while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();

    return x;

}

const int N = 100005;

int m,n;

struct ope{ int op,x; }a[N];

int b[N];

set<int> s;

int root,cnt,ch[N*2][2],sz[N*2],lazy[N*2],num[N*2];

int pos[N];

void build(int x,int l,int r){

    sz[x]=lazy[x]=num[x]=0;

    if(l==r) { pos[l]=x; return; }

    int mid=(l+r)>>1;

    build(ch[x][0]=++cnt,l,mid);

    build(ch[x][1]=++cnt,mid+1,r);

}

void pushdown(int x){

    if(lazy[x]==0) return ;

    lazy[ch[x][0]]+=lazy[x];

    lazy[ch[x][1]]+=lazy[x];

    lazy[x]=0;

}

void addsz(int x,int l,int r,int c,int d){

    sz[x]+=d;

    if(l==r) return;

    pushdown(x);

    int mid=(l+r)>>1;

    if(c<=mid) addsz(ch[x][0],l,mid,c,d);

    else addsz(ch[x][1],mid+1,r,c,d);

}

void addnum(int x,int l,int r,int c,int d){

    num[x]+=d;

    if(l==r) return;

    pushdown(x);

    int mid=(l+r)>>1;

    if(c<=mid) addnum(ch[x][0],l,mid,c,d);

    else addnum(ch[x][1],mid+1,r,c,d);

}

void adddep(int x,int l,int r,int L,int R,int c){

    if(L<=l && r<=R) { lazy[x]+=c; return; }

    pushdown(x);

    int mid=(l+r)>>1;

    if(L<=mid) adddep(ch[x][0],l,mid,L,R,c);

    if(R>mid) adddep(ch[x][1],mid+1,r,L,R,c);

}

void cgdep(int x,int l,int r,int c,int d){

    if(l==r) { lazy[x]=d; return; }

    pushdown(x);

    int mid=(l+r)>>1;

    if(c<=mid) cgdep(ch[x][0],l,mid,c,d);

    else cgdep(ch[x][1],mid+1,r,c,d);

}

int find(int x,int l,int r,int c){

    if(l==r) return l;

    pushdown(x);

    int mid=(l+r)>>1;

    if(sz[ch[x][0]]>=c) return find(ch[x][0],l,mid,c);

    return find(ch[x][1],mid+1,r,c-sz[ch[x][0]]);

}

int cal(int x,int l,int r,int c){

    if(l==r) return num[x];

    pushdown(x);

    int mid=(l+r)>>1;

    if(c<=mid) return cal(ch[x][0],l,mid,c);

    return num[ch[x][0]]+cal(ch[x][1],mid+1,r,c);

}

int dep(int x,int l,int r,int c){

    if(l==r) return lazy[x];

    pushdown(x);

    int mid=(l+r)>>1;

    if(c<=mid) return dep(ch[x][0],l,mid,c);

    return dep(ch[x][1],mid+1,r,c);

}

int rt,fa[N],son[N][2];

void mkrt_min(int x){

    if(x+1<=fa[x]-1) adddep(root,1,n,x+1,fa[x]-1,-1);

    adddep(root,1,n,1,n,1);

    cgdep(root,1,n,x,1);

    son[fa[x]][0]=son[x][1];

    if(son[x][1]) fa[son[x][1]]=fa[x];

    else addsz(root,1,n,fa[x],1),addsz(root,1,n,x,-1);

    fa[rt]=x; son[x][1]=rt; rt=x; fa[x]=0;

}

void mkrt_max(int x){

    if(fa[x]+1<=x-1) adddep(root,1,n,fa[x]+1,x-1,-1);

    adddep(root,1,n,1,n,1);

    cgdep(root,1,n,x,1);

    son[fa[x]][1]=son[x][0];

    if(son[x][0]) fa[son[x][0]]=fa[x];

    else addsz(root,1,n,fa[x],1),addsz(root,1,n,x,-1);

    fa[rt]=x; son[x][0]=rt; rt=x; fa[x]=0;

}

int main()

{

    m=read();

    for(int i=0;i<m;i++){

        a[i].op=read();

        a[i].x= (a[i].op==1) ? read() :  0 ;

        if(a[i].x) b[++n]=a[i].x;

    }

    sort(b+1,b+1+n);

    n=unique(b+1,b+1+n)-b-1;

    build(root=++cnt,1,n);

    for(int i=0;i<m;i++){

        if(a[i].op==1){

            int x=lower_bound(b+1,b+1+n,a[i].x)-b;

            if(s.size()==0){

                s.insert(x);

                rt=x;

                addsz(root,1,n,x,2);

                cgdep(root,1,n,x,1);

                addnum(root,1,n,x,1);

                printf("1\n");

            }

            else{

                s.insert(x);

                int y=find(root,1,n,cal(root,1,n,x)+1),d=dep(root,1,n,y)+1;

                fa[x]=y;

                son[fa[x]][x>fa[x]]=x;

                addsz(root,1,n,fa[x],-1);

                addsz(root,1,n,x,2);

                cgdep(root,1,n,x,d);

                addnum(root,1,n,x,1);

                printf("%d\n",d);

            }

        }

        else if(a[i].op==2){

            int x=*s.begin();

            if(rt==x) printf("1\n");

            else{

                printf("%d\n",dep(root,1,n,x));

                mkrt_min(x);

            }

        }

        else if(a[i].op==3){

            int x=*(--s.end());

            if(rt==x) printf("1\n");

            else{

                printf("%d\n",dep(root,1,n,x));

                mkrt_max(x);

            }

        }

        else if(a[i].op==4){

            int x=*s.begin();

            if(rt==x) printf("1\n");

            else{

                printf("%d\n",dep(root,1,n,x));

                mkrt_min(x);

            }

            adddep(root,1,n,1,n,-1);

            addsz(root,1,n,x,-sz[pos[x]]);

            addnum(root,1,n,x,-1);

            rt=son[x][1]; son[x][1]=0; fa[rt]=0;

            s.erase(x);

        }

        else{

            int x=*(--s.end());

            if(rt==x) printf("1\n");

            else{

                printf("%d\n",dep(root,1,n,x));

                mkrt_max(x);

            }

            adddep(root,1,n,1,n,-1);

            addsz(root,1,n,x,-sz[pos[x]]); /**/

            addnum(root,1,n,x,-1);

            rt=son[x][0]; son[x][0]=0; fa[rt]=0;

            s.erase(x);

        }

    }

    return 0;

}