【HDOJ】5096 ACM Rank

Treap+set仿函数重定义。每当ac一道题目时，相当于对总时间减去一个大数。

 /* 5096 */
 #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

 const int maxn = ;
 const int BigInt = 1e7;
 int S[maxn], top, tot, root;
 int lst[maxn], lstac[maxn];
 bool mark[maxn][];
 int pen[maxn][];
 int T[maxn];
 char cmd[], line[];

 typedef struct fcmp {
     bool operator() (const int& a, const int& b) {
         if (lstac[a]==- && lstac[b]==-)
             return a<b;
         if (lstac[a]!=- && lstac[b]!=-)
             return lstac[a]<lstac[b];
         else if (lst[a] == -)
             return false;
         else
             return true;
     }
 } fcmp;

 typedef struct Node {
     int ch[];
     int r, s, v, c;
     set<int, fcmp> st;

     Node() {}

     void setId(int v_, int id) {
         v = v_;
         st.clr();
         st.insert(id);
         ch[] = ch[] = ;
         r = rand();
         s = c = ;
     }

     int cmp(int x) const {
         if (x == v)    return -;
         return x<v ? :;
     }

     void insert(int id) {
         st.insert(id);
     }

     void erase(int id) {
         st.erase(id);
     }
 } Node;

 Node nd[maxn];

 void newNode(int& r, int id, int v) {
     if (top) {
         r = S[--top];
     } else {
         r = ++tot;
     }
     nd[r].setId(v, id);
 }

 void maintain(int r) {
     nd[r].s = nd[nd[r].ch[]].s + nd[nd[r].ch[]].s + nd[r].c;
 }

 void Rotate(int& r, int d) {
     int k = nd[r].ch[d^];
     nd[r].ch[d^] = nd[k].ch[d];
     nd[k].ch[d] = r;
     maintain(r);
     maintain(k);
     r = k;
 }

 void Insert(int& r, int id, int v) {
     if (r == ) {
         newNode(r, id, v);
         return ;
     } else {
         int d = nd[r].cmp(v);
         if (d == -) {
             ++nd[r].c;
             ++nd[r].s;
             nd[r].insert(id);
             return ;
         }
         Insert(nd[r].ch[d], id, v);
         if (nd[nd[r].ch[d]].r > nd[r].r)
             Rotate(r, d^);
     }
     maintain(r);
 }

 void Remove(int& r, int id, int v) {
     int d = nd[r].cmp(v);

     if (d == -) {
         if (nd[r].c > ) {
             --nd[r].c;
             --nd[r].s;
             nd[r].erase(id);
             return ;
         }

         if (nd[r].ch[] && nd[r].ch[]) {
             int d2 = nd[nd[r].ch[]].r > nd[nd[r].ch[]].r ? :;
             Rotate(r, d2);
             Remove(nd[r].ch[d2], id, v);
         } else {
             S[top++] = r;
             r = nd[r].ch[] + nd[r].ch[];
         }
     } else {
         Remove(nd[r].ch[d], id, v);
     }

     if (r)
         maintain(r);
 }

 void init() {
     nd[].ch[] = nd[].ch[] = nd[].s = nd[].v = nd[].c = ;
     memset(pen, , sizeof(pen));
     memset(mark, false, sizeof(mark));
     memset(lst, -, sizeof(lst));
     memset(lstac, -, sizeof(lstac));
     memset(T, , sizeof(T));
     top = tot = root = ;
 }

 int Rank(int r, int v) {
     int d = nd[r].cmp(v);
     int sz = nd[nd[r].ch[]].s;

     if (d == -)
         return sz+;
     else if (d == )
         return Rank(nd[r].ch[], v);
     else
         return sz+nd[r].c+Rank(nd[r].ch[], v);
 }

 int kth(int r, int k) {
     if (r== || k<= || k>nd[r].s)    return -;
     int sz = nd[nd[r].ch[]].s;

     if (k <= sz) {
         return kth(nd[r].ch[], k);
     } else if (k <= sz+nd[r].c) {
         if (k == sz+) {
             return *nd[r].st.begin();
         } else {
             return -;
         }
     } else {
         return kth(nd[r].ch[], k-sz-nd[r].c);
     }

 }

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

     int n, m;
     int ino;
     int t, k, tno, res, pid;
     int ans;

     while (scanf("%d %d", &n, &m)!=EOF) {
         init();
         ino = ;
         rep(i, , n) {
             Insert(root, i, );
         }
         while () {
             scanf("%s %s", cmd, line);
             ++ino;
             if (cmd[] == 'C')
                 break;
             if (cmd[] == 'T') {
                 int len = strlen(line);
                 int i = ;

                 k = ;
                 while (i < len) {
                     k =  * k + line[i]-'';
                     ++i;
                 }
                 ans = kth(root, k);
                 printf("%d\n", ans);
             } else if (cmd[] == 'R') {
                 int len = strlen(line);
                 int i = ;

                 tno = ;
                 while (i < len) {
                     tno =  * tno + line[i]-'';
                     ++i;
                 }
                 t = T[tno];
                 ans = Rank(root, t);
                 printf("%d\n", ans);
             } else if (cmd[] == 'S') {
                 int len = strlen(line);
                 int i = ;

                 t = ;
                 while (i<len && line[i]!=':') {
                     t =  * t + line[i]-'';
                     ++i;
                 }

                 tno = ;
                 ++i;
                 while (i<len && line[i]!=':') {
                     tno =  * tno + line[i]-'';
                     ++i;
                 }

                 ++i;
                 pid = line[i++] - 'A';

                 res = ;
                 ++i;
                 while (i < len) {
                     res =  * res + line[i]-'';
                     ++i;
                 }

                 if (mark[tno][pid])
                     continue;
                 if (lst[tno]>= && t-lst[tno]<)
                     continue;
                 if (res != ) {
                     pen[tno][pid] += ;
                     lst[tno] = t;
                     continue;
                 }
                 printf("[%d][%c]\n", tno, pid+'A');
                 Remove(root, tno, T[tno]);
                 T[tno] += pen[tno][pid];
                 T[tno] += t;
                 mark[tno][pid] = true;
                 T[tno] -= BigInt;
                 lst[tno] = t;
                 lstac[tno] = ino;
                 Insert(root, tno, T[tno]);
             }
         }
         putchar('\n');
     }

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

     return ;
 }