在平衡树的海洋中畅游（二）——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;
}

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