fjutacm 2492 宠物收养所 ： Splay 模板 O(nlogn)

 /**
 problem: http://www.fjutacm.com/Problem.jsp?pid=2492
 Splay blog: https://tiger0132.blog.luogu.org/slay-notes
 函数介绍:
 内部函数：
     root为指针， x为数值
     bool check(int root)：返回当前结点为父节点的左结点还是右结点（0为左结点，1为右结点）
     void pushUp(int root)：旋转后维护结点信息
     void rotate(int root)：关键函数，旋转结点
     void splay(int root, int target = 0)：Splay核心，将root结点旋转至target子结点，target为0则旋转到树根
     void find(int x): 将数值为x的结点旋转至树根
     int pre(int x)：寻找数值为x的结点的前驱结点，返回指针
     int succ(int x)：寻找数值为x的结点的后继节点，返回指针
 外部函数：
     void clear()：清空平衡树
     void insert(T x)：插入数值为x的数
     int rank(T x)：返回数值为x的数为第几小
     T preAns(T x)：返回刚好比数值x小的数是多少
     T succAns(T x)：返回刚好比数值x大的数是多少
     T kth(int k)：返回第k小的数是多少
     void remove(T x)：删除数值为x的结点，如果有多个则数量-1
     T top(T x)：如果有数值为x的结点返回x，否则返回其他数
     int getAllSize()：返回平衡树中有多少个数
 **/

 #include<stdio.h>
 #include<algorithm>
 #include<queue>
 using namespace std;

 typedef long long ll;
 const ll MOD = ;

 template<typename T>
 class Splay{
     const static int MAXN = ;
     const static T INF = 0x3f3f3f3f3f3f3f3fLL;
 private:
     struct Node{
         int ch[];
         int cnt, size, parent;
         T val;
     }node[MAXN];
     int treeroot, sign, allSize;
     queue<int> freeMemory;
     bool check(int root){ /// right return 1 else return 0
         return node[node[root].parent].ch[] == root;
     }
     void pushUp(int root){
         node[root].size = node[node[root].ch[]].size + node[node[root].ch[]].size + node[root].cnt;
     }
     void rotate(int root){
         int father = node[root].parent, grandpa = node[father].parent, direction = check(root), child = node[root].ch[direction^];
         node[father].ch[direction] = child; node[child].parent = father;
         node[grandpa].ch[check(father)] = root; node[root].parent = grandpa;
         node[root].ch[direction^] = father; node[father].parent = root;
         pushUp(father); pushUp(root);
     }
     void splay(int root, int target = ){ /// if target == 0 then root to treeroot
         while(node[root].parent != target){
             int father = node[root].parent, grandpa = node[father].parent;
             if(grandpa != target){
                 if(check(root) == check(father)) rotate(father);
                 else rotate(root);
             }
             rotate(root);
         }
         if(!target) treeroot = root;
     }
     void find(int x){
         if(!treeroot) return;
         int cur = treeroot;
         while(node[cur].ch[x > node[cur].val] && node[cur].val != x){
             cur = node[cur].ch[x > node[cur].val];
         }
         splay(cur);
     }
     int pre(int x){
         find(x);
         if(node[treeroot].val < x) return treeroot;
         if(!node[treeroot].ch[]) return -;
         int cur = node[treeroot].ch[];
         while(node[cur].ch[]){
             cur = node[cur].ch[];
         }
         return cur;
     }
     int succ(int x){
         find(x);
         if(node[treeroot].val > x) return treeroot;
         if(!node[treeroot].ch[]) return -;
         int cur = node[treeroot].ch[];
         while(node[cur].ch[]){
             cur = node[cur].ch[];
         }
         return cur;
     }
 public:
     void clear(){
         sign = ;
         insert(INF);
         insert(-INF);
         allSize = ;
     }
     void insert(T x){
         allSize ++;
         int cur = treeroot, preroot = ;
         while(cur && node[cur].val != x){
             preroot = cur;
             cur = node[cur].ch[x > node[cur].val];
         }
         if(cur){
             node[cur].cnt ++;
         }else{
             if(freeMemory.empty())
                 cur = ++ sign;
             else{
                 cur = freeMemory.front();
                 freeMemory.pop();
             }
             if(preroot) node[preroot].ch[x > node[preroot].val] = cur;
             node[cur].val = x;
             node[cur].cnt = ;
             node[cur].ch[] = node[cur].ch[] = ;
             node[cur].size = ;
             node[cur].parent = preroot;
         }
         splay(cur);
     }
     int rank(T x){
         find(x);
         return node[node[treeroot].ch[]].size;
     }
     T preAns(T x){
         return node[pre(x)].val;
     }
     T succAns(T x){
         return node[succ(x)].val;
     }
     T kth(int k){
         k ++;
         int cur = treeroot;
         while(){
             if(node[cur].ch[] && k <= node[node[cur].ch[]].size){
                 cur = node[cur].ch[];
             }else if(k > node[node[cur].ch[]].size + node[cur].cnt){
                 k -= node[node[cur].ch[]].size + node[cur].cnt;
                 cur = node[cur].ch[];
             }else{
                 return node[cur].val;
             }
         }
     }
     void remove(T x){
         allSize --;
         int last = pre(x), next = succ(x);
         splay(last), splay(next, last);
         int del = node[next].ch[];
         if(node[del].cnt > ){
             node[del].cnt --;
             splay(del);
         }else{
             freeMemory.push(node[next].ch[]);
             node[next].ch[] = ;
         }
     }
     T top(T x){
         find(x);
         return node[treeroot].val;
     }
     int getAllSize(){
         return allSize;
     }
 };

 Splay<ll> splay;

 int main(){
     int n;
     ll ans = ;
     bool type = ;
     scanf("%d", &n);
     splay.clear();
     while(n --){
         int a;
         ll b;
         scanf("%d%lld", &a, &b);
         if(a){
             if(type || splay.getAllSize() == ){
                 splay.insert(b);
                 type = ;
             }
             else{
                 ll pre = splay.preAns(b), mid = splay.top(b), succ = splay.succAns(b);
                 ll choose;
                 if(abs(pre - b) <= abs(mid - b)){
                     choose = pre;
                 }else{
                     choose = mid;
                 }
                 if(abs(choose - b) > abs(succ - b)){
                     choose = succ;
                 }
                 ans = (ans + abs(choose - b)) % MOD;
                 splay.remove(choose);
             }
         }else{
             if(!type || splay.getAllSize() == ){
                 splay.insert(b);
                 type = ;
             }
             else{
                 ll pre = splay.preAns(b), mid = splay.top(b), succ = splay.succAns(b);
                 ll choose;
                 if(abs(pre - b) <= abs(mid - b)){
                     choose = pre;
                 }else{
                     choose = mid;
                 }
                 if(abs(choose - b) > abs(succ - b)){
                     choose = succ;
                 }
                 ans = (ans + abs(choose - b)) % MOD;
                 splay.remove(choose);
             }
         }
     }
     printf("%lld\n", ans);
     return ;
 }