codevs1985: GameZ游戏排名系统(Treap)

题目

　　GameZ为他们最新推出的游戏开通了一个网站。世界各地的玩家都可以将自己的游戏得分上传到网站上。这样就可以看到自己在世界上的排名。得分越高，排名就越靠前。当两个玩家的名次相同时，先上传记录者优先。由于新游戏的火爆，网站服务器已经难堪重负。为此GameZ雇用了你来帮他们重新开发一套新的核心。 排名系统通常要应付三种请求：上传一条新的得分记录、查询某个玩家的当前排名以及返回某个区段内的排名记录。当某个玩家上传自己最新的得分记录时，他原有的得分记录会被删除。为了减轻服务器负担，在返回某个区段内的排名记录时，最多返回10条记录。

输入描述

　　第一行是一个整数n（n>=10）表示请求总数目。
　　接下来n行每行包含了一个请求。请求的具体格式如下：
　　　　+Name Score 上传最新得分记录。Name表示玩家名字，由大写英文字母组成，不超过10个字符。Score为不超过无符号32位整型表示范围的非负整数。
　　　　?Name 查询玩家排名。该玩家的得分记录必定已经在前面上传。
　　　　?Index 返回自第Index名开始的最多10名玩家名字。Index必定合法，即不小于1，也不大于当前有记录的玩家总数。
　　20%数据满足N<=100
　　100%数据满足N<=250000
　　时间限制为2s
　　输入数据大小不超过2M。
　　NOTE：用C++的fstream读大规模数据的效率较低。

输出描述

对于每条查询请求，输出相应结果。对于?Name格式的请求，应输出一个整数表示该玩家当前的排名。对于?Index格式的请求，应在一行中依次输出从第Index名开始的最多10名玩家姓名，用一个空格分隔。

样例输入

20
+ADAM 1000000
+BOB 1000000
+TOM 2000000
+CATHY 10000000
?TOM
?1
+DAM 100000
+BOB 1200000
+ADAM 900000
+FRANK 12340000
+LEO 9000000
+KAINE 9000000
+GRACE 8000000
+WALT 9000000
+SANDY 8000000
+MICK 9000000
+JACK 7320000
?2
?5
?KAINE

样例输出

2
CATHY TOM ADAM BOB
CATHY LEO KAINE WALT MICK GRACE SANDY JACK TOM BOB
WALT MICK GRACE SANDY JACK TOM BOB ADAM DAM
4

分析

题目中共有三种操作, 而n最大可达250000, 所以这三张操作的时间复杂度应不劣于O(logn), 可以考虑用Treap来实现. Treap是什么? Treap时一种平衡树. Treap = Trea + Heap, 顾名思义, Treap把BST(二叉查找树)和Heap结合了起来, 它和BST一样满足许多优美的性质, 而引入堆的目的就是为了维护平衡, 具有简明易懂, 易于编写, 稳定性佳等优点.[1]
下图是Treap和其他平衡树的比较:

在这里不赘述Treap的具体实现, 只讨论Treap的应用.
在这道题中, Treap的结点应该保存有名字, 分数, 时间戳, 子树大小这些信息.
对于第一种操作+Name Score, 先删除原有的结点, 再插入新的结点, 这是平衡树的基本操作, 时间复杂度为O(logn).
对于第二种操作?Name, 直接查找, 时间复杂度也为O(logn).
对于第三种操作?Index, 题目说明了最多只需要输出10位玩家的名字, 即查找排名在[index, min(index+9, all] 区间内的玩家. 我们在结点中已经保存了子树大小这一信息, 于是也可以O(logn)完成这一操作.
具体实现看代码.

代码

#include<bits/stdc++.h>
#define x first
#define y second
#define ok puts("ok");
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const double PI = acos(-1.0);
const int INF=0x3f3f3f3f;
const ll LINF=0x3f3f3f3f3f3f3f3f;
const int N=3e5+9;
const int shift=1e3+9;
const double Eps=1e-7;

int n, tot, timer, score, sco[N], tim[N];
char c;
string s, r[N];
map<string, int> m;

//Treap结点
struct node {
    int id, score, timer, fix, size;    //字符串映射id, 分数, 时间戳, 修正值, 子树大小
    node *left, *right;                 //左右子树
    inline int lsize() {return left?left->size:0;}      //求左子树大小
    inline int rsize() {return right?right->size:0;}    //求右子树大小
};

//左旋
void leftRotate(node *&a) {
    node *b = a->right;     //与BST的左旋操作相似
    a->right = b->left;
    b->left = a;
    a = b;
    b = a->left;
    b->size = b->lsize() + b->rsize() + 1;  //修正经过旋转操作后受影响的结点的子树大小
    a->size = a->lsize() + a->rsize() + 1;
}

//右旋
void rightRotate(node *&a) {
    node *b = a->left;      //与BST的右旋操作相似
    a->left = b->right;
    b->right = a;
    a = b;
    b = a->right;
    b->size = b->lsize() + b->rsize() + 1;  //修正经过旋转操作后受影响的结点的子树大小
    a->size = a->lsize() + a->rsize() + 1;
}

//插入
void insert(node *&p, int id, int score, int timer) {
    if(!p) {
        p = new node;
        p->id = id;
        p->score = score;
        p->timer = timer;
        p->fix = rand();        //用随机函数生成修正值
        p->left = p->right = NULL;
        p->size = 1;
    }
    else if(score <= p->score) {
        insert(p->left, id, score, timer);
        if(p->left->fix < p->fix)   //维护堆的特性, 从而保证BST的平衡, 该题维护的是最小堆, 换成最大堆也是OK的
            rightRotate(p);
        else
            p->size = p->lsize() + p->rsize() + 1;
    }
    else {
        insert(p->right, id, score, timer);
        if(p->right->fix < p->fix)  //维护堆的特性, 从而保证BST的平衡
            leftRotate(p);
        else
            p->size = p->lsize() + p->rsize() + 1;
    }
}

//删除
void del(node *&p, int score, int timer) {
    if(p->score == score && p->timer == timer) { //找到了待删除结点
        if(!p->left || !p->right) { //假如是叶子结点或者链结点(只有一个儿子的结点), 直接删除
            node *t = p;
            if(!p->right)
                p=p->left;
            else
                p=p->right;
            delete t;
        }
        else {
            if(p->left->fix < p->right->fix) {  //假如左儿子的修正值小于右儿子的修正值, 进行右旋
                rightRotate(p);
                del(p->right, score, timer);
                p->size = p->lsize() + p->rsize() + 1;
            }
            else {                              //假如左儿子的修正值大于右儿子的修正值, 进行左旋
                leftRotate(p);
                del(p->left, score, timer);
                p->size = p->lsize() + p->rsize() + 1;
            }
        }
    }
    else if(score < p->score || (score == p->score && timer > p->timer)) {  //待删除结点在p的左子树中
        del(p->left, score, timer);
        p->size = p->lsize() + p->rsize() + 1;
    }
    else {      //待删除结点在p的右子树中
        del(p->right, score, timer);
        p->size = p->lsize() + p->rsize() + 1;
    }
}

//查找排在第k的玩家
int findK(node *&p, int k) {
    if(k < p->lsize() + 1)
        return findK(p->left, k);
    else if(k > p->lsize() + 1)
        return findK(p->right, k-(p->lsize()+1));
    return p->id;
}

//查找分数为score且时间戳为timer的玩家
int search(node *&p, int score, int timer, int rank) {
    if(p->score == score && p->timer == timer)
        return rank;
    else if(score < p->score || (score == p->score &&timer > p->timer))
        return search(p->left, score, timer, rank - p->left->rsize() - 1);
    else
        return search(p->right, score, timer, rank + p->right->lsize() + 1);
}

int main(void) {
    node *root = NULL;
    int n; cin >> n;
    while(n--) {
        getchar();
        c = getchar();
        if(c == '+') {
            cin >> s >> score;
            if(m[s]) {  //假如该玩家之前已上传过分数
                int id = m[s];
                del(root, sco[id], tim[id]);        //先删除
                insert(root, id, score, ++timer);   //后插入
                sco[id] = score, tim[id] = timer;   //记录分数和时间戳, 作为查找操作的信息
            }
            else {      //假如该玩家首次上传分数
                m[s] = ++tot;
                r[tot] = s;
                insert(root, tot, score, ++timer);
                sco[tot] = score, tim[tot] = timer;
            }
        }
        else {
            cin>>s;
            if(isdigit(s[0])) {
                int all = root->lsize() + root->rsize() + 1, t = 0, k = 1;
                for(int i = s.length()-1; i >= 0; i--) {
                    t += (s[i] - '0') * k;
                    k *= 10;
                }
                for(int i = t; i <= min(t+9, all); i++) {
                    int t1 = findK(root, all-i+1);  //二叉树中查找排名第1的, 其实是排在倒数第1, 所以需要反过来
                    if(i == min(t+9, all))
                        cout << r[t1] << endl;
                    else
                        cout << r[t1] << ' ';
                }
            }
            else {
                int id = m[s];
                int ans = search(root, sco[id], tim[id], root->lsize() + 1);
                int all = root->lsize() + root->rsize() + 1;
                cout << all-ans+1 << endl;
            }
        }
    }

    return 0;
}