【HDOJ】3436 Queue-jumpers

离散化+伸展树。

 /* 3436 */
 #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 {
     char c;
     int x;
 } Cmd;

 const int maxq = 1e5+;
 const int maxn = 3e5+;
 int pre[maxn], ch[maxn][], s[maxn], key[maxn], pos[maxn];
 int arr[maxn], cnt[maxn];
 int b[maxn], e[maxn];
 int tot, root, n, m;
 Cmd cmd[maxq];

 int search(int x) {
     int l = , r = m - , mid;
     int ret = -;

     while (l <= r) {
         mid = (l + r) >> ;
         if (b[mid]<=x && x<=e[mid])
             return mid;
         if (e[mid] < x) {
             l = mid + ;
         } else {
             r = mid - ;
         }
     }

     return ret;
 }

 void newNode(int& r, int k, int fa) {
     r = tot++;
     pre[r] = fa;
     ch[r][] = ch[r][] = ;
     key[r] = k;
     pos[k] = r;
     s[r] = cnt[r] = e[k] - b[k] + ;
 }

 void PushUp(int r) {
     s[r] = s[ch[r][]] + s[ch[r][]] + cnt[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];
     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) {
     while (pre[r] != goal) {
         if (pre[pre[r]] == goal) {
             Rotate(r, ch[pre[r]][]==r);
         } else {
             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;
 }

 void Insert(int& r, int k, int fa) {
     if (r == ) {
         newNode(r, k, fa);
         return ;
     }
     Insert(ch[r][], k, r);
     PushUp(r);
 }

 int getMin(int r) {
     while (ch[r][]) {
         r = ch[r][];
     }
     return r;
 }

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

     if (k <= sz)
         return kth(ch[r][], k);
     else if (k <= sz+cnt[r])
         return b[key[r]] + k - sz - ;
     else
         return kth(ch[r][], k-sz-cnt[r]);
 }

 int Rank(int x) {
     return kth(root, x);
 }

 int Query(int x) {
     int k = search(x);
     int p = pos[k];

     Splay(p, );
     return s[ch[root][]] + ;
 }

 void Delete() {
     int k = getMin(ch[root][]);

     Splay(k, root);
     ch[ch[root][]][] = ch[root][];
     root = ch[root][];
     pre[ch[root][]] = root;
     pre[root] = ;
     PushUp(root);
 }

 void top(int x) {
     int k = search(x);
     int p = pos[k];

     Splay(p, );
     if (ch[root][]== || ch[root][]==) {
         root = ch[root][] + ch[root][];
         pre[root] = ;
     } else {
         Delete();
     }
     Insert(root, k, );
     Splay(pos[k], );
 }

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

     inorder(ch[rt][]);
     printf("rt = %2d: lson = %2d, rson = %2d, fa = %2d, size = %2d, key = %2d, num = %2d \n",
         rt, ch[rt][], ch[rt][], pre[rt], s[rt], key[rt], cnt[rt]);
     inorder(ch[rt][]);
 }

 void init() {
     root = tot = ;
     ch[root][] = ch[root][] = s[root] = pre[root] = cnt[root] = key[root] = ;
     tot = ;
     Build(root, , m-, );
     #ifndef ONLINE_JUDGE
         // inorder(root);
     #endif
 }

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

     int t, q;
     int l, x;
     int ans;
     char event[];

     scanf("%d", &t);
     rep(tt, , t+) {
         printf("Case %d:\n", tt);
         scanf("%d %d", &n, &q);
         l = ;
         arr[l++] = ;
         rep(i, , q) {
             scanf("%s %d", event, &cmd[i].x);
             if (event[] != 'R')
                 arr[l++] = cmd[i].x;
             cmd[i].c = event[];
         }
         arr[l++] = n;
         sort(arr, arr+l);

         m = ;
         rep(i, , l) {
             if (arr[i] != arr[i-]) {
                 if (arr[i]-arr[i-] > ) {
                     b[m] = arr[i-] + ;
                     e[m] = arr[i] - ;
                     ++m;
                 }
                 b[m] = e[m] = arr[i];
                 ++m;
             }
         }

         init();
         rep(i, , q) {
             if (cmd[i].c == 'T') {
                 top(cmd[i].x);
             } else if (cmd[i].c == 'Q') {
                 ans = Query(cmd[i].x);
                 printf("%d\n", ans);
             } else {
                 ans = Rank(cmd[i].x);
                 printf("%d\n", ans);
             }
             #ifndef ONLINE_JUDGE
                 printf("iteration [%d]:\n", i);
                 inorder(root);
             #endif
         }
     }

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

     return ;
 }