替罪羊树

Noip复赛过后第一次更博！

一种神奇的数据结构：替罪羊树

您需要写一种数据结构，来维护一些数，其中需要提供以下操作：

1. 插入x数
2. 删除x数(若有多个相同的数，因只删除一个)
3. 查询x数的排名(若有多个相同的数，因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x，且最大的数)
6. 求x的后继(后继定义为大于x，且最小的数)

　　其实这道题的做法很多，splay之类的都能过，不过相较于那种繁琐的通过旋转来保持树的平衡，替罪羊树则是把失去平衡的树直接重构，对，就是暴力重构，下面我来简略说明替罪羊树的操作原理（其实我也不是很会）

先说明几个量的含义：

u.cnt u的子树大小
u.size u的实际子树大小（指除去所有标记点后）
alpha 一个常数，一般取值在0.6~0.8之间，用于判断子树大小是否失衡

基本操作如下：

1.插入：就是普通BST的插入即可
注意：在插入的过程中在对于每一个节点，统计其子树的大小，对于某棵子树u，其左子树  left_u，如果alpha*u.cnt<=left_u.cnt,则直接将该子树重构。
2. 删除：替罪羊树的删除不是直接将那个节点从树中删去，而是为其打上标记，在统计 答案时不再计入。
注意：再标记后，对于某棵子树u，若u.cnt*alpha>u.size,,则直接将子树u重构
3.重构：对于子树u，我们将其没有被标记的节点按中序遍历存到数组里，然后在取数组中间的位置作为根，重新建起一棵子树。

附上代码（BZOJ3224）

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const double alpha=0.75;  
int ls[200010],rs[200010],siz[200010],travel[200010],cnt[200010],stk[400010],v[200010];  
int n,top,t1,root,goat;  
bool exist[100010];  
int rank(int x)
{
    int now=root;
    int ans=1;
    while (now)
    {
        if (v[now]>=x) now=ls[now];
        else
        {
            ans+=siz[ls[now]]+exist[now];
            now=rs[now];
        }
    }
    return ans;
}
void dfs(int rt)
{
    if (!rt) return;
    dfs(ls[rt]);
    if (exist[rt]) travel[++t1]=rt;
    else stk[++top]=rt;
    dfs(rs[rt]);
}
void build(int &rt,int l,int r)
{
    int mid=(l+r)>>1;
    rt=travel[mid];
    if (l==r)
    {
        siz[rt]=cnt[rt]=1;
        ls[rt]=rs[rt]=0;
        return;
    }
    if (l<mid) build(ls[rt],l,mid-1);
    else ls[rt]=0;
    build(rs[rt],mid+1,r);
    siz[rt]=siz[ls[rt]]+siz[rs[rt]]+1;
    cnt[rt]=cnt[ls[rt]]+cnt[rs[rt]]+1;
}
void rebuild(int &rt)
{
    t1=0;
    dfs(rt);
    if (t1) build(rt,1,t1);
    else rt=0;
}
void insert(int &rt,int x)
{
    if (rt==0)
    {
        rt=stk[top--];v[rt]=x;
        siz[rt]=cnt[rt]=exist[rt]=1;
        ls[rt]=rs[rt]=0;
        return;
    }
    siz[rt]++;cnt[rt]++;
    if (x<=v[rt]) insert(ls[rt],x);
    else insert(rs[rt],x);
    if ((double)siz[rt]*alpha>(double)max(siz[ls[rt]],siz[rs[rt]]))
    {
        if (goat)
        {
            if (ls[rt]==goat) rebuild(ls[rt]);
            else rebuild(rs[rt]);
            goat=0;
        }
    }
    else goat=rt;
}
void del_id(int &rt,int x)
{
    if (exist[rt] && x==siz[ls[rt]]+1)
    {
        exist[rt]=0;
        siz[rt]--;
        return;
    }
    siz[rt]--;
    if (x<=siz[ls[rt]]+exist[rt]) del_id(ls[rt],x);
    else del_id(rs[rt],x-siz[ls[rt]]-exist[rt]);
}
void del_val(int x)
{
    del_id(root,rank(x));
    if ((double)siz[root]<(double)alpha*cnt[root]) rebuild(root);
}
int get_xth(int x)
{
    int now=root;
    while (now)
    {
        if (exist[now] && x==siz[ls[now]]+1) return v[now];
        else if (siz[ls[now]]>=x) now=ls[now];
        else
        {
            x-=siz[ls[now]]+exist[now];
            now=rs[now];
        }
    }
}
int main()
{
    scanf("%d",&n);
    root=0;
    for (int i=400000;i>=1;i--) stk[++top]=i;
    int opt,x;
    for (int i=1;i<=n;i++)
    {
        scanf("%d%d",&opt,&x);
        if (opt==1) insert(root,x);
        if (opt==2) del_val(x);
        if (opt==3) printf("%d\n",rank(x));
        if (opt==4) printf("%d\n",get_xth(x));
        if (opt==5) printf("%d\n",get_xth(rank(x)-1));
        if (opt==6) printf("%d\n",get_xth(rank(x+1)));
    }
    return 0;
}