在平衡樹的海洋中暢遊（二）——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;
}

——識替罪羊樹之算法乃吾生之幸也！