替罪羊树 ------ luogu P3369 【模板】普通平衡树（Treap/SBT）

二次联通门 : luogu P3369 【模板】普通平衡树（Treap/SBT）

闲的没事，把各种平衡树都写写

比较比较。。。

下面是替罪羊树

#include <cstdio>
#include <vector>

#define Max_ 100010

#define Inline __attri\
bute__( ( optimize( "-O2" ) ) )

Inline void read (int &now)
{
    register char word = getchar ();
    bool temp = false;
    for (now = ; word < '' || word > ''; word = getchar ())
        if (word == '-')
            temp = true;
    for (; word >= '' && word <= ''; now = now *  + word - '', word = getchar ());
    if (temp)
        now = -now;
}

const double alpha = 0.63;

int N;

struct G_D
{
    G_D *child[];

    int key;
    int size, total;
    bool is_exist;

    inline void Up ()
    {
        this->size = this->child[]->size + this->child[]->size + is_exist;
        this->total = this->child[]->total + this->child[]->total + ;
    }

    inline bool is_rebuild ()
    {
        return ((this->child[]->total > this->total * alpha + ) || (this->child[]->total > this->total * alpha + ));
    }
};

class Scapegoat_Tree_Type
{

    private :

        G_D poor_mem[Max_];
        G_D *Root, *Tail, *null;

        G_D *reuse[Max_];
        int Reuse_top;

        Inline G_D *New_Node (int key)
        {
            G_D *now = Reuse_top ? reuse[-- Reuse_top] : Tail ++;
            now->child[] = now->child[] = null;
            now->size = now->total = ;
            now->is_exist = true;
            now->key = key;
            return now;
        }

        Inline void Travel (G_D *now, std :: vector <G_D *> &line)
        {
            if (now == null)
                return ;
            Travel (now->child[], line);
            if (now->is_exist)
                line.push_back (now);
            else
                reuse[Reuse_top ++] = now;
            Travel (now->child[], line);
        }

        Inline G_D *Divide (std :: vector <G_D *> &line, int l, int r)
        {
            if (l >= r)
                return null;
            int Mid = (l + r) >> ;
            G_D *now = line[Mid];
            now->child[] = Divide (line, l, Mid);
            now->child[] = Divide (line, Mid + , r);
            now->Up ();
            return now;
        }

        Inline void Re_Build (G_D *&now)
        {
            static std :: vector <G_D *> line;
            line.clear ();
            Travel (now, line);
            now = Divide (line, , line.size ());
        }

        Inline G_D **Insert (G_D *&now, int key)
        {
            if (now == null)
            {
                now = New_Node (key);
                return &null;
            }
            else
            {
                now->size ++;
                now->total ++;
                G_D **res = Insert (now->child[key >= now->key], key);
                if (now->is_rebuild ())
                    res = &now;
                return res;
            }
        }

        Inline void Erase (G_D *now, int pos)
        {
            now->size --;
            int res = now->child[]->size + now->is_exist;
            if (now->is_exist && pos == res)
            {
                now->is_exist = false;
                return ;
            }
            else
            {
                if (pos <= res)
                    Erase (now->child[], pos);
                else
                    Erase (now->child[], pos - res);
            }
        }

    public :

        Scapegoat_Tree_Type ()
        {
            Tail = poor_mem;
            null = Tail ++;
            null->child[] = null->child[] = null;
            null->total = null->size = null->key = ;

            Root = null;
            Reuse_top = ;
        }

        Inline void Insert (int key)
        {
            G_D **now = this->Insert (Root, key);
            if (*now != null)
                Re_Build (*now);
        }

        Inline int Get_Rank (int key)
        {
            G_D *now = Root;
            register int Answer = ;
            for (; now != null; )
            {
                if (now->key >= key)
                    now = now->child[];
                else
                {
                    Answer += now->child[]->size + now->is_exist;
                    now = now->child[];
                }
            }
            return Answer;
        }

        Inline int Get_kth_number (int k)
        {
            int Count = ;
            for (G_D *now = Root; now != null; )
            {
                if (now->child[]->size +  == k && now->is_exist)
                    return now->key;
                else if (now->child[]->size >= k)
                    now = now->child[];
                else
                {
                    k -= now->child[]->size + now->is_exist;
                    now = now->child[];
                }
            }
        }

        Inline  void Erase (int pos)
        {
            Erase (Root, Get_Rank (pos));
            if (Root->size < alpha * Root->total)
                Re_Build (Root);
        }

};

Scapegoat_Tree_Type Tree;

int M;
int main (int argc, char *argv[])
{

    read (M);

    for (int type, x; M --; )
    {
        read (type);
        read (x);

        switch (type)
        {
            case :
                Tree.Insert (x);
                break;
            case :
                Tree.Erase (x);
                break;
            case :
                printf ("%d\n", Tree.Get_Rank (x));
                break;
            case :
                printf ("%d\n", Tree.Get_kth_number (x));
                break;
            case :
                printf ("%d\n", Tree.Get_kth_number (Tree.Get_Rank (x) - ));
                break;
            case :
                printf ("%d\n", Tree.Get_kth_number (Tree.Get_Rank (x + )));
                break;
        }
    }

    return ;
}