数组splay ------ luogu P3369 【模板】普通平衡树（Treap/SBT）

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

#include <cstdio>

#define Max 100005

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

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

class Splay_Tree_Type
{
    private:

        struct Tree_Date
        {
            int weigth;
            int size;
            int key;
            int child[];
            int father;
        }
        tree[Max];

        Inline int Get_Son (int now)
        {
            return tree[tree[now].father].child[] == now;
        }

        int Count;
        int Root;

    public :

        Inline void Update (int now)
        {
            tree[now].size = tree[now].weigth;
            if (tree[now].child[])
                tree[now].size += tree[tree[now].child[]].size;
            if (tree[now].child[])
                tree[now].size += tree[tree[now].child[]].size;
        }

        Inline void Rotate (int now)
        {
            int father = tree[now].father;
            int Grand = tree[father].father;
            int pos = Get_Son (now);
            tree[father].child[pos] = tree[now].child[pos ^ ];
            tree[tree[father].child[pos]].father = father;
            tree[now].child[pos ^ ] = father;
            tree[father].father = now;
            tree[now].father = Grand;
            if (Grand)
                tree[Grand].child[tree[Grand].child[] == father] = now;
            Update (father);
            Update (now);
        }

        Inline void Splay (int now)
        {
            for (int father; father = tree[now].father; Rotate (now))
                if (tree[father].father)
                    Rotate (Get_Son (now) == Get_Son (father) ? father : now);
            Root = now;
        }

        Inline int Find_Prefix ()
        {
            int now = tree[Root].child[];
            while (tree[now].child[])
                now = tree[now].child[];
            return now;
        }

        Inline int Find_Suffix ()
        {
            int now = tree[Root].child[];
            while (tree[now].child[])
                now = tree[now].child[];
            return now;
        }

        Inline void Clear (int now)
        {
            tree[now].child[] = ;
            tree[now].child[] = ;
            tree[now].size = ;
            tree[now].weigth = ;
            tree[now].key = ;
            tree[now].father = ;
        }

        Inline int Find_x_rank (int x)
        {
            int now = Root;
            int Answer = ;
            while (true)
            {
                if (x < tree[now].key)
                {
                    now = tree[now].child[];
                    continue;
                }
                Answer += tree[now].child[] ? tree[tree[now].child[]].size : ;
                if (tree[now].key == x)
                {
                    Splay (now);
                    return Answer + ;
                }
                Answer += tree[now].weigth;
                now = tree[now].child[];
            }
        }

        Inline int Find_rank_x (int x)
        {
            int now = Root;
            while (true)
            {
                if (tree[now].child[] && x <= tree[tree[now].child[]].size)
                {
                    now = tree[now].child[];
                    continue;
                }
                int temp = (tree[now].child[] ? tree[tree[now].child[]].size : ) + tree[now].weigth;
                if (x <= temp)
                    return tree[now].key;
                x -= temp;
                now = tree[now].child[];
            }
        }

        Inline void Insert (int x)
        {
            if (!Root)
            {
                Count++;
                tree[Count].key = x;
                tree[Count].size = ;
                tree[Count].weigth = ;
                Root = Count;
                return;
            }
            int father = , now = Root;
            while (true)
            {
                if (tree[now].key == x)
                {
                    tree[now].size++;
                    tree[now].weigth++;
                    Splay (now);
                    return ;
                }
                father = now;
                now = tree[now].child[x > tree[father].key];
                if (!now)
                {
                    Count++;
                    tree[father].child[x > tree[father].key] = Count;
                    tree[Count].father = father;
                    tree[Count].key = x;
                    tree[Count].size = ;
                    tree[Count].weigth = ;
                    Splay (Count);
                    return ;
                }
            }
        }

        Inline void Delete (int x)
        {
            Find_x_rank (x);
            if (tree[Root].weigth > )
            {
                tree[Root].weigth--;
                tree[Root].size--;
                return ;
            }
            if (!tree[Root].child[] && !tree[Root].child[])
            {
                Clear (Root);
                Root = ;
                return ;
            }
            if (!tree[Root].child[])
            {
                int temp = Root;
                Root = tree[Root].child[];
                tree[Root].father = ;
                Clear (temp);
                return ;
            }
            if (!tree[Root].child[])
            {
                int temp = Root;
                Root = tree[Root].child[];
                tree[Root].father = ;
                Clear (temp);
                return ;
            }
            int Prefix = Find_Prefix ();
            int temp = Root;
            Splay (Prefix);
            tree[Root].child[] = tree[temp].child[];
            tree[tree[temp].child[]].father = Root;
            Clear (temp);
            Update (Root);
        }

        Inline int Get_tree_value (int now)
        {
            return tree[now].key;
        }
};

Splay_Tree_Type Splay_Tree;

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

    read (N);
    int type, x;

    for (; N--; )
    {
        read (type);
        read (x);
        if (type == )
            Splay_Tree.Insert (x);
        else if (type == )
            Splay_Tree.Delete (x);
        else if (type == )
            printf ("%d\n", Splay_Tree.Find_x_rank (x));
        else if (type == )
            printf ("%d\n", Splay_Tree.Find_rank_x (x));
        else if (type == )
        {
            Splay_Tree.Insert (x);
            printf ("%d\n", Splay_Tree.Get_tree_value (Splay_Tree.Find_Prefix ()));
            Splay_Tree.Delete (x);
        }
        else
        {
            Splay_Tree.Insert (x);
            printf ("%d\n", Splay_Tree.Get_tree_value (Splay_Tree.Find_Suffix ()));
            Splay_Tree.Delete (x);
        }
    }

    return ;
}