4825: [Hnoi2017]单旋

4825: [Hnoi2017]单旋

链接

分析：

　　以后采取更保险的方式写代码！！！81行本来以为不特判也可以，然后就总是比答案大1，甚至出现负数，调啊调啊调啊调~~~

　　只会旋转最大值和最小值，以最小值为例，画一下图可以看出，旋转后，深度分成三部分讨论，最小值的深度（变为1），最小值右子树的深度（不变），其他的点的深度（整体加1）。所以线段树维护一下。

　　现在考虑如何插入一个点，可以知道一个点加入后一定是在前驱的右边，或者后继的左边。一个性质：前驱后继一定在splay上是一个是另一个的祖先的关系（反证：若中间存在一个点为它们两个的祖先，那么这个点前驱后继一定有一个是中间的点，没有重复的数字）。那么这个点加入的过程中，一定是加入在前驱后继中比较深的一个点。所以可以直接找到前驱后继，深度大的就是它的父节点。

　　找到根据splay的性质找到相应的区间，进行区间加减，单点求值。前驱后继可以直接在线段树上二分，或者直接用set。（或者直接splay）

代码：

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<iostream>
 #include<cmath>
 #include<cctype>
 #include<set>
 #include<queue>
 #include<vector>
 #include<map>
 #define Root 1, tot, 1
 #define lson l, mid, rt << 1
 #define rson mid + 1, r, rt << 1 | 1
 #define Clear(x) ch[x][0] = ch[x][1] = fa[x] = 0
 using namespace std;
 typedef long long LL;

 inline int read() {
     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;
     for(;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;
 }

 const int N = ;

 int T[N << ], tag[N << ], ch[N][], fa[N], a[N], disc[N], opt[N], Rt;
 set<int> s;
 set<int> :: iterator it;

 void pushdown(int rt) {
     tag[rt << ] += tag[rt]; tag[rt <<  | ] += tag[rt];
     T[rt << ] += tag[rt], T[rt <<  | ] += tag[rt];
     tag[rt] = ;
 }
 void update(int l,int r,int rt,int L,int R,int v) {
     if (L <= l && r <= R) {
         tag[rt] += v; T[rt] += v; return;
     }
     if (tag[rt]) pushdown(rt);
     int mid = (l + r) >> ;
     if (L <= mid) update(lson, L, R, v);
     if (R > mid) update(rson, L, R, v);
 }
 void Change(int l,int r,int rt,int p,int v) {
     if (l == r) { T[rt] = v, tag[rt] = ; return ; }
     if (tag[rt]) pushdown(rt);
     int mid = (l + r) >> ;
     if (p <= mid) Change(lson, p, v);
     if (p > mid) Change(rson, p, v);
 }
 int query(int l,int r,int rt,int p) {
     if (l == r) return T[rt];
     if (tag[rt]) pushdown(rt);
     int mid = (l + r) >> ;
     if (p <= mid) return query(lson, p);
     if (p > mid) return query(rson, p);
 }
 int main() {
     int n = read(), tot = ;
     for (int i = ; i <= n; ++i) {
         opt[i] = read();
         if (opt[i] == ) a[i] = read(), disc[++tot] = a[i];
     }
     s.insert(-1e9), s.insert(1e9);
     sort(disc + ,disc + tot + );
     for (int i = ; i <= n; ++i) if (opt[i] == ) a[i] = lower_bound(disc + , disc + tot + , a[i]) - disc;

     for (int pre, suc, now, mx, mn, i = ; i <= n; ++i) {
         if (opt[i] == ) {
             it = s.lower_bound(a[i]); suc = *it; pre = *(--it); now = ;
             int d1 = -, d2 = -;
             if (pre != -1e9) d1 = query(Root, pre);
             if (suc != 1e9) d2 = query(Root, suc);
             if (d1 > d2) now = d1 + , fa[a[i]] = pre, ch[pre][] = a[i];
             if (d1 < d2) now = d2 + , fa[a[i]] = suc, ch[suc][] = a[i];
             if (now == ) Rt = a[i], Clear(Rt);
             Change(Root, a[i], now);
             s.insert(a[i]);
         }
         else if (opt[i] & ) {
             it = s.end(); it --; it --; mx = *it; now = query(Root, mx);
             if (mx != Rt) { // 注意！！！此处需特判！！！！！！！！！！！！！
                 update(Root, , mx - , );
                 if (fa[mx] +  <= mx - ) {
                     update(Root, fa[mx] + , mx - , -);
                 }
                 fa[ch[mx][]] = fa[mx]; ch[fa[mx]][] = ch[mx][];
                 ch[mx][] = Rt; fa[Rt] = mx; Rt = mx; fa[mx] = ;
                 Change(Root, mx, );
             }
             if (opt[i] == ) {
                 Rt = ch[mx][], fa[Rt] = ; Clear(mx);
                 s.erase(s.find(mx));
                 update(Root, , tot, -);
             }
         }
         else {
             it = s.begin(); it ++; mn = *it; now = query(Root, mn);
             if (mn != Rt) {
                 update(Root, mn + , tot, );
                 if (mn +  <= fa[mn] - ) {
                     update(Root, mn + , fa[mn] - , -);
                 }
                 fa[ch[mn][]] = fa[mn]; ch[fa[mn]][] = ch[mn][];
                 ch[mn][] = Rt; fa[Rt] = mn; Rt = mn; fa[mn] = ;
                 Change(Root, mn, );
             }
             if (opt[i] == ) {
                 Rt = ch[mn][]; fa[Rt] = ; Clear(mn);
                 s.erase(s.find(mn));
                 update(Root, , tot, -);
             }
         }
         printf("%d\n",now);
     }
     return ;
 }