【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+;
 int pre[maxn], ch[maxn][], 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][] = ch[r][] = ;
     size[r] = ;
     rev[r] = ;
 }

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

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

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

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

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

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

 void Rotate(int x, int d) {
     int y = pre[x];
     PushDown(y);
     PushDown(x);
     ch[y][d^] = ch[x][d];
     pre[ch[x][d]] = y;
     if (pre[y])
         ch[pre[y]][ch[pre[y]][]==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]][]==r);
         } else {
             PushDown(pre[pre[r]]);
             PushDown(pre[r]);
             PushDown(r);
             int y = pre[r];
             int d = ch[pre[y]][]==y;
             if (ch[y][d] == r) {
                 Rotate(r, d^);
                 Rotate(r, d);
             } else {
                 Rotate(y, d);
                 Rotate(r, d);
             }
         }
     }

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

 int kth(int r, int k) {
     int sz = size[ch[r][]] + ;

     PushDown(r);
     if (k == sz)
         return r;
     if (k < sz)
         return kth(ch[r][], k);
     else
         return kth(ch[r][], k-sz);
 }

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

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

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

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

 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, , n+) {
             scanf("%d", &nd[i].val);
             nd[i].id = i;
         }
         init();
         sort(nd+, nd++n);
         rep(i, , n+) {
             r = nd[i].id;
             Splay(r, );
             ans[i] = size[ch[root][]];
             Splay(kth(root, i), );
             Splay(getNext(r), root);
             UpdateRev(grandlson);
         }
         rep(i, , n+) {
             printf("%d", ans[i]);
             if (i == n)
                 putchar('\n');
             else
                 putchar(' ');
         }
     }

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

     return ;
 }