【HDOJ】1890 Robotic Sort

伸展树伤不起啊，很容易wa，很容易T，很容易M。

/* 1890 */
#include <iostream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1
#define grandlson        ch[ch[root][1]][0]

typedef struct node_t {
    int id, val;
    node_t() {}
    friend bool operator<(const node_t& a, const node_t& b) {
        if (a.val != b.val)
            return a.val < b.val;
        return a.id < b.id;
    }
} node_t;

const int maxn = 1e5+10;
int pre[maxn], ch[maxn][2], size[maxn], rev[maxn];
node_t nd[maxn];
int root, tot, n;
int ans[maxn];

void newNode(int& r, int k, int fa) {
    r = k;
    pre[r] = fa;
    ch[r][0] = ch[r][1] = 0;
    size[r] = 1;
    rev[r] = 0;
}

void PushUp(int r) {
    size[r] = size[ch[r][0]] + size[ch[r][1]] + 1;
}

void UpdateRev(int r) {
    if (r == 0)    return ;

    swap(ch[r][0], ch[r][1]);
    rev[r] ^= 1;
}

void PushDown(int r) {
    if (rev[r]) {
        UpdateRev(ch[r][0]);
        UpdateRev(ch[r][1]);
        rev[r] = 0;
    }
}

void Build(int& rt, int l, int r, int fa) {
    if (l > r)    return ;

    int mid = (l + r) >> 1;
    newNode(rt, mid, fa);
    Build(ch[rt][0], l, mid-1, rt);
    Build(ch[rt][1], mid+1, r, rt);
    PushUp(rt);
}

void Rotate(int x, int d) {
    int y = pre[x];
    PushDown(y);
    PushDown(x);
    ch[y][d^1] = ch[x][d];
    pre[ch[x][d]] = y;
    if (pre[y])
        ch[pre[y]][ch[pre[y]][1]==y] = x;
    pre[x] = pre[y];
    ch[x][d] = y;
    pre[y] = x;
    PushUp(y);
}

void Splay(int r, int goal) {
    
    PushDown(r);
    while (pre[r] != goal) {
        if (pre[pre[r]] == goal) {
            PushDown(pre[r]);
            PushDown(r);
            Rotate(r, ch[pre[r]][0]==r);
        } else {
            PushDown(pre[pre[r]]);
            PushDown(pre[r]);
            PushDown(r);
            int y = pre[r];
            int d = ch[pre[y]][0]==y;
            if (ch[y][d] == r) {
                Rotate(r, d^1);
                Rotate(r, d);
            } else {
                Rotate(y, d);
                Rotate(r, d);
            }
        }
    }

    PushUp(r);
    if (goal == 0)
        root = r;
}

int kth(int r, int k) {
    int sz = size[ch[r][0]] + 1;
    
    PushDown(r);
    if (k == sz)
        return r;
    if (k < sz)
        return kth(ch[r][0], k);
    else
        return kth(ch[r][1], k-sz);
}

int getNext(int rt) {
    PushDown(rt);
    if (ch[rt][1] == 0)        return -1;
    rt = ch[rt][1];
    while (ch[rt][0]) {
        rt = ch[rt][0];
        PushDown(rt);
    }
    return rt;
}

void init() {
    ch[root][0] = ch[root][1] = size[root] = rev[root] = 0;
    newNode(root, n+1, 0);
    newNode(ch[root][1], n+2, root);
    Build(grandlson, 1, n, ch[root][1]);
    PushUp(ch[root][1]);
    PushUp(root);
}

void inorder(int rt) {
    if (rt == 0)    return ;

    inorder(ch[rt][0]);
    printf("rt = %d, lson = %d, rson = %d, fa = %d, sz = %d, rev = %d\n",
        rt, ch[rt][0], ch[rt][1], pre[rt], size[rt], rev[rt]);
    inorder(ch[rt][1]);
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    int r;

    while (scanf("%d", &n)!=EOF && n) {
        rep(i, 1, n+1) {
            scanf("%d", &nd[i].val);
            nd[i].id = i;
        }
        init();
        sort(nd+1, nd+1+n);
        rep(i, 1, n+1) {
            r = nd[i].id;
            Splay(r, 0);
            ans[i] = size[ch[root][0]];
            Splay(kth(root, i), 0);
            Splay(getNext(r), root);
            UpdateRev(grandlson);
        }
        rep(i, 1, n+1) {
            printf("%d", ans[i]);
            if (i == n)
                putchar('\n');
            else
                putchar(' ');
        }
    }

    #ifndef ONLINE_JUDGE
        printf("time = %d.\n", (int)clock());
    #endif

    return 0;
}