在平衡树的海洋中畅游（二）——Scapegoat Tree

在平衡树的广阔天地中，以Treap,Splay等为表明的经过旋转来维护平衡的文艺平衡树占了觉大部分。

然而，今天咱们要讲的Scapegoat Tree（替罪羊树）就是一个特立独行的平衡树，它经过暴力重构来维护平衡，而且凭借着好写，好调，常数小等特色十分有用。

记得g1n0st说过：

暴力便是优雅。

固然这里说的暴力并非指那种不加以思考的无脑的暴力，而是说用繁琐而技巧性的工做能够实现的事，我用看似简单的思想和方法，也能够达到近似于前者的空间复杂度和时间复杂度，甚至能够更优，而其中也或多或少的夹杂着一些" Less is more "的思想在其中。

而替罪羊树的重构就充满了暴力美学，一言不合就把整棵子树拍扁重建，好比一棵这样的树：

而这样很显然，根的右子树（以\(11\)为根）的子树太深了，咱们给它手动拍扁：

而后接回去就变成了：

至于如何有序，咱们想一下二叉树的中序遍历，不是能够直接用线性时间把那个拍扁后的序列得出来了。

而后咱们发现重构虽然能够维持树的形状，但它自己的较大的复杂度开销也会引发TLE，所以咱们要控制重构的次数。

咱们引入一个平衡因子\(alpha\)，通常取值在\([0,7,0.8]\)之间，当一棵子树的左右子树的节点个数的较大值大于这棵子树总的节点个数\(\cdot alpha\)时，咱们就把这棵子树拍扁重构。

特殊地，当一个点被插入时，若是有多个要被重建的节点，那们咱们就把以最高的（深度最小的）节点（又叫替罪羊节点）为根的整棵子树重构便可。

形象的理解一下：子树要被重建不是我原来根的锅，可是我就是被拍扁了还被重建了。果真不负替罪羊树的称号。

而后在删除时，咱们若是直接删除因为没有旋转操做，大量的重构可能会引发TLE。

所以咱们像线段树的lazy标记同样，在删除一个点时直接打标记删除便可。

而后又是板子题的CODE

#include<cstdio>
#include<cctype>
using namespace std;
typedef double DB;
const int N=100005;
const DB alpha=0.75;
struct Scapegoat
{
    int ch[2],size,fac,val;
    bool exi;
}node[N];//size是子树总大小（算上被删除的点），fac是实际上子树总大小（不计被删除的点），exi表示是否被删除
int cur[N],mempol[N],cnt,tot,n,opt,x,rt,st;
inline char tc(void)
{
    static char fl[100000],*A=fl,*B=fl;
    return A==B&&(B=(A=fl)+fread(fl,1,100000,stdin),A==B)?EOF:*A++;
}
inline void read(int &x)
{
    x=0; char ch; int flag=1; while (!isdigit(ch=tc())) flag=ch^'-'?1:-1;
    while (x=(x<<3)+(x<<1)+ch-'0',isdigit(ch=tc())); x*=flag;
}
inline void write(int x)
{
    if (x<0) putchar('-'),x=-x;
    if (x>9) write(x/10);
    putchar(x%10+'0');
}
inline int max(int a,int b)
{
    return a>b?a:b;
}
inline bool balance(int now)//判断是否平衡
{
    return (DB)node[now].fac*alpha>(DB)max(node[node[now].ch[0]].fac,node[node[now].ch[1]].fac);
}
inline void pushup(int now)
{
    node[now].size=node[node[now].ch[0]].size+node[node[now].ch[1]].size+1;
    node[now].fac=node[node[now].ch[0]].fac+node[node[now].ch[1]].fac+1;
}
inline void build(int now)
{
    node[now].ch[0]=node[now].ch[1]=0;
    node[now].size=node[now].fac=1;
}
inline void traversal(int now)//中序遍历
{
    if (!now) return; traversal(node[now].ch[0]);
    if (node[now].exi) cur[++cnt]=now; else mempol[++tot]=now;
    traversal(node[now].ch[1]);
}
inline void setup(int l,int r,int &now)//将被拍扁的序列接成一棵树，注意每次取端点保证深度最小
{
    int mid=l+r>>1; now=cur[mid];
    if (l==r) { build(now); return; }
    if (l<mid) setup(l,mid-1,node[now].ch[0]); else node[now].ch[0]=0;
    setup(mid+1,r,node[now].ch[1]); pushup(now);
}
inline void rebuild(int &now)//重构
{
    cnt=0; traversal(now);
    if (cnt) setup(1,cnt,now); else now=0;
}
inline void insert(int &now,int val)//插入，仍是遵循BST的性质
{
    if (!now)
    {
        now=mempol[tot--]; node[now].val=val; node[now].exi=1;
        build(now); return;
    }
    ++node[now].size; ++node[now].fac;
    if (val<=node[now].val) insert(node[now].ch[0],val); else insert(node[now].ch[1],val);
}
inline void check(int now,int val)//在插入时检查合法性，一言不和就重构
{
    int d=val<=node[now].val?0:1;
    while (node[now].ch[d])
    {
        if (!balance(node[now].ch[d])) { rebuild(node[now].ch[d]); break; }
        now=node[now].ch[d]; d=val<=node[now].val?0:1;
    }
}
inline int get_rk(int val)//获得排名，因为和许多的BST相似，就再也不赘述
{
    int now=rt,rk=1;
    while (now)
    {
        if (val<=node[now].val) now=node[now].ch[0];
        else rk+=node[node[now].ch[0]].fac+node[now].exi,now=node[now].ch[1];
    }
    return rk;
}
inline int get_val(int rk)//获得排名为rk的数
{
    int now=rt;
    while (now)
    {
        if (node[now].exi&&node[node[now].ch[0]].fac+1==rk) return node[now].val;
        else if (node[node[now].ch[0]].fac>=rk) now=node[now].ch[0];
        else rk-=node[node[now].ch[0]].fac+node[now].exi,now=node[now].ch[1];
    }
}
inline void remove_rk(int &now,int rk)//删除排名为rk的数
{
    if (node[now].exi&&node[node[now].ch[0]].fac+1==rk) { node[now].exi=0; --node[now].fac; return; }
    --node[now].fac; if (node[node[now].ch[0]].fac+node[now].exi>=rk) remove_rk(node[now].ch[0],rk);
    else remove_rk(node[now].ch[1],rk-node[node[now].ch[0]].fac-node[now].exi);
}
inline void remove_val(int val)//删除值为val的数，注意若是实际上的点已经不多了也要重构
{
    remove_rk(rt,get_rk(val));
    if ((double)node[rt].size*alpha>node[rt].fac) rebuild(rt);
}
inline void init(void)
{
    for (register int i=100000;i>=1;--i)
    mempol[++tot]=i;
}
int main()
{
    //freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
    read(n); init();
    while (n--)
    {
        read(opt); read(x);
        switch (opt)
        {
            case 1:st=rt,insert(rt,x),check(st,x); break;
            case 2:remove_val(x); break;
            case 3:write(get_rk(x)),putchar('\n'); break;
            case 4:write(get_val(x)),putchar('\n'); break;
            case 5:write(get_val(get_rk(x)-1)),putchar('\n'); break;
            case 6:write(get_val(get_rk(x+1))),putchar('\n'); break;
        }
    }
    return 0;
}

——识替罪羊树之算法乃吾生之幸也！