[hdu][1890][Robotic Sort]

题目：http://acm.hdu.edu.cn/showproblem.php?pid=1890

伸展树，按照题意模拟，把所求第i个节点旋转至根节点，reverse一下

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

#define keytree root->ch[1]->ch[0]

using namespace std;

const int M = 100000+10;
const int inf = 0x3f3f3f3f;

struct node
{
    int size, rev, key;
    node *ch[2], *pre;
    void reverse()
    {
        if (size == 0)return ;
        rev ^= 1;
        swap(ch[0], ch[1]);
    }
    void update()
    {
        size = ch[0]->size + ch[1]->size + 1;
    }
    void pushdown()
    {
        if (rev) ch[0]->reverse(), ch[1]->reverse(), rev = 0;
    }
};

int arr[M];
node * hash[M];

class Splay
{
    public:
        node *root, *null;
        node *newnode(int var)
        {
            node *p;
            if (top) p = stk[top--];
            else p = &data[cnt++];
            p->key = var;
            p->size = 1;
            p->rev = 0;
            p->ch[0] = p->ch[1] = p->pre = null;
            return p;
        }
        void init()
        {
            top = cnt = 0;
            null = newnode(inf);
            null->size = 0;
            root = newnode(inf);
            root->ch[1] = newnode(inf);
            root->ch[1]->pre = root;
            root->update();
        }
        node *build(int l, int r)
        {
            if (l > r) return null;
            int mid = (l + r) >> 1;
            node *p = newnode(arr[mid]);
            hash[arr[mid]] = p;
            p->ch[0] = build(l, mid-1);
            p->ch[1] = build(mid+1, r);
            if (p->ch[0] != null)
                p->ch[0]->pre = p;
            if (p->ch[1] != null)
                p->ch[1]->pre = p;
            p->update();
            return p;
        }
        void maketree(int l, int r)
        {
            init();
            keytree = build(l, r);
            keytree->pre = root->ch[1];
            splay(keytree, null);
        }
        void rotate(node *x, int c)
        {
            node *y = x->pre;
            y->pushdown();
            x->pushdown();
            y->ch[!c] = x->ch[c];
            if (x->ch[c] != null)
                x->ch[c]->pre = y;
            x->pre = y->pre;
            if (y->pre != null)
                y->pre->ch[ y==y->pre->ch[1] ] = x;
            x->ch[c] = y;
            y->pre = x;
            y->update();
            if (y == root) root = x;
        }
        void splay(node *x, node *f)
        {
            x->pushdown();
            while (x->pre != f)
            {
                if (x->pre->pre == f)
                {
                    rotate(x, x->pre->ch[0] == x);
                    break;
                }
                node *y = x->pre;
                node *z = y->pre;
                int c = (y == z->ch[0]);
                if (x == y->ch[c])
                    rotate(x, !c), rotate(x, c);
                else
                    rotate(y, c), rotate(x, c);
            }
            x->update();
        }
        void select(int kth, node *x)
        {
            node * cur = root;
            while (true)
            {
                cur->pushdown();
                int tmp = cur->ch[0]->size;
                if (tmp == kth) break;
                else if (tmp < kth)
                    kth -= tmp + 1, cur = cur->ch[1];
                else cur = cur->ch[0];
            }
            splay(cur, x);
        }
        void reverse(int x, int y)
        {
            select(x-1, null);
            select(y+1, root);
            keytree->reverse();
        }
        int getans(int x, int y)
        {
            splay(hash[y], null);           // 第y个转换至根节点
            int ans = root->ch[0]->size;    // 求出数目
            reverse(x, ans);                // 反转一下
            return ans;
        }
    private:
        int cnt, top;
        node *stk[M], data[M];
}spt;

struct Num
{
    int x, y;
    bool operator < (const Num& a)const
    {
        if (x == a.x) return y < a.y;
        return x < a.x;
    }
}num[M];

int main()
{
    int n, a;
    while (~scanf("%d", &n) && n)
    {
        for (int i=1; i<=n; i++)
            scanf("%d", &a), num[i].x = a, num[i].y = i, arr[i] = i;
        sort(num+1, num+n+1);
        spt.maketree(1, n);
        for (int i=1; i<n; i++)
        {
            printf("%d ", spt.getans(i, num[i].y));
        }
        printf("%d\n", n);
    }
    return 0;
}