[HNOI 2017]单旋

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

题解

参考了PIPIBoss的做法。

我们手玩一下单旋，发现其如果只改变最大最小值时，主要的性质就是整棵$splay$的形态不会发生很大的改变。

例如旋最小值到根，其实就相当于将最小值的节点取出来，最小值的右儿子连向最小值的父亲。接着再把最小值对应的节点接在原来的根的父亲上。

最大值同理。那么就可以用$LCT$维护了。

对于插入操作，很显然的是这个新插入的节点肯定接向其前驱的右儿子或后继的左儿子。另外，这两个儿子肯定有一个是空的，有一个不空。另外，不空的儿子就是前驱和后继两个中深度较深节点的儿子。

我们将权值离散，找前驱后继就交给$STL-set$，另外还要额外开数组来记录原来$splay$树的形态。

 //It is made by Awson on 2017.12.27
 #include <map>
 #include <set>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <cstdio>
 #include <string>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define LD long double
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 using namespace std;
 const int N = 1e5;
 const int INF = ~0u>>;

 int m, a[N+], top;
 struct Opt {
     int opt, x;
 }q[N+];
 struct Link_Cut_Tree {
     int ch[N+][], pre[N+], size[N+], isrt[N+], rev[N+];
     set<int>S;
     int f[N+], c[N+][], root;
     Link_Cut_Tree () {
     for (int i = ; i <= N; i++) size[i] = isrt[i] = ;
     S.insert(-INF), S.insert(INF);
     }
     void pushdown(int o) {
     if (!o || !rev[o]) return;
     int ls = ch[o][], rs = ch[o][];
     swap(ch[ls][], ch[ls][]), swap(ch[rs][], ch[rs][]);
     rev[ls] ^= , rev[rs] ^= , rev[o] = ;
     }
     void push(int o) {
     if (!isrt[o]) push(pre[o]);
     pushdown(o);
     }
     void pushup(int o) {
     if (!o) return;
     size[o] = size[ch[o][]]+size[ch[o][]]+;
     }
     void rotate(int o, int kind) {
     int p = pre[o];
     ch[p][!kind] = ch[o][kind], pre[ch[o][kind]] = p;
     if (isrt[p]) isrt[o] = , isrt[p] = ;
     else ch[pre[p]][ch[pre[p]][] == p] = o;
     pre[o] = pre[p];
     ch[o][kind] = p, pre[p] = o;
     pushup(p), pushup(o);
     }
     void splay(int o) {
     push(o);
     while (!isrt[o]) {
         if (isrt[pre[o]]) rotate(o, ch[pre[o]][] == o);
         else {
         int p = pre[o], kind = ch[pre[p]][] == p;
         if (ch[p][kind] == o) rotate(o, !kind), rotate(o, kind);
         else rotate(p, kind), rotate(o, kind);
         }
     }
     }
     void access(int o) {
     int y = ;
     while (o) {
         splay(o); size[o] -= size[ch[o][]];
         isrt[ch[o][]] = , isrt[ch[o][] = y] = ;
         o = pre[y = o];
         pushup(o);
     }
     }
     void makeroot(int o) {
     access(o), splay(o);
     rev[o] ^= , swap(ch[o][], ch[o][]);
     }
     void link(int x, int y) {
     if (!x || !y) return;
     makeroot(x); pre[x] = y;
     }
     void cut(int x, int y) {
     if (!x || !y) return;
     makeroot(x), access(y), splay(y);
     size[y] -= size[x];
     ch[y][] = pre[x] = , isrt[x] = ;
     }
     int query(int x, int y) {
     makeroot(x), access(y), splay(y);
     return size[ch[y][]]+;
     }
     int insert(int x) {
     if (!root) {
         root = x; S.insert(x); return ;
     }
     int pre = *(--S.lower_bound(x)), nex = *(S.upper_bound(x)), o;
     if (pre == -INF) o = nex;
     else if (nex == INF) o = pre;
     else {
         int depx = query(root, pre), depy = query(root, nex);
         if (depx > depy) o = pre;
         else o = nex;
     }
     f[x] = o, c[o][x > o] = x; link(o, x); S.insert(x);
     return query(root, x);
     }
     int find_min() {
     int o = *(++S.begin()), fa = f[o], child = c[o][];
     int ans = query(root, o);
     if (o != root) {
         cut(o, fa), cut(child, o), link(child, fa), link(root, o);
         c[o][] = root, f[root] = o; root = o; f[o] = ; c[fa][] = child, f[child] = fa;
     }
     return ans;
     }
     int find_max() {
     int o = *(--(--S.end())), fa = f[o], child = c[o][];
     int ans = query(root, o);
     if (o != root) {
         cut(o, fa), cut(child, o), link(child, fa), link(root, o);
         c[o][] = root, f[root] = o; root = o; f[o] = ; c[fa][] = child, f[child] = fa;
     }
     return ans;
     }
     int del_min() {
     int o = *(++S.begin()), fa = f[o], child = c[o][];
     int ans = query(root, o);
     cut(o, fa), cut(o, child); link(fa, child);
     f[child] = fa, c[fa][] = child;
     S.erase(S.find(o)); f[o] = c[o][] = c[o][] = ;
     if (root == o) root = child, f[child] = ;
     return ans;
     }
     int del_max() {
     int o = *(--(--S.end())), fa = f[o], child = c[o][];
     int ans = query(root, o);
     cut(o, fa), cut(o, child); link(fa, child);
     f[child] = fa, c[fa][] = child;
     S.erase(S.find(o)); f[o] = c[o][] = c[o][] = ;
     if (root == o) root = child, f[child] = ;
     return ans;
     }
 }T;

 void work() {
     scanf("%d", &m);
     for (int i = ; i <= m; i++) {
     scanf("%d", &q[i].opt);
     if (q[i].opt == ) {
         scanf("%d", &q[i].x); a[++top] = q[i].x;
     }
     }
     sort(a+, a++top); top = unique(a+, a+top+)-a-;
     for (int i = ; i <= m; i++) {
     if (q[i].opt == ) printf("%d\n", T.insert(lower_bound(a+, a+top+, q[i].x)-a));
     else if (q[i].opt == ) printf("%d\n", T.find_min());
     else if (q[i].opt == ) printf("%d\n", T.find_max());
     else if (q[i].opt == ) printf("%d\n", T.del_min());
     else printf("%d\n", T.del_max());
     }
 }
 int main() {
     work();
     return ;
 }