洛谷P5338 [TJOI2019]甲苯先生的滚榜

原题链接洛谷P5338 [TJOI2019]甲苯先生的滚榜

题目描述

甲苯先生在制作一个online judge，他发现做比赛的人们很关心自己的排名(显而易见),在acm赛制的比赛中，如果通过题目数量不相等，则通过题目数量多的人排名更靠前，如果通过题目数量相等，

则罚时更少的人排名更高。甲苯先生想让大家帮忙设计一个程序，每次有人通过之后，就告诉他排名在他的前面有多少人。(不包括和他罚时题数都相同的同学)

输入输出格式

输入格式：

第一行输入一个整数T表示样例数。

对于每一个样例:输入三个整数m, n, seed。m表示参赛总人数(编号1−m)，n表示一共有n次accept(假设accept已经去重，即不存在相同人的相同题目提交)。seed表示生成数据的种子。

接下来要求同学们使用之下的函数生成数据

typedef unsigned int ui;
    ui randNum(ui& seed, ui last, const ui m) {
    seed = seed *  + last;
    return seed % m + ;
}

（last为上一次输出的结果,在没有输出结果时last=7)

要求每次生成两个数据Ria, Rib 表示Ria的人Accept了一道题目，他的罚时为Rib。（也就是说Ria的题目数量+1，罚时长度+Rib）。

要求一共生成n组数据，代表一共有n次提交

对于所有数据，保证罚时总和不超过1500000

输出格式：

每次提交输出一行整数，表示Ria在ac后比Ria成绩高的有多少选手。

输入输出样例

输入样例#1： 复制

1
7 3 1

输出样例#1： 复制

0
1
0

说明

测试点#　　1, 2　　　　3, 4 　　　　5 　　　6, 7, 8　　　　9, 10

T　　　　　≤10　　　　≤5 　　　　≤15　　　　≤5　　　　　　≤5

m　　　　　≤1000　　　≤10000 　　≤10^5　　　≤10^4　　　　　≤10^5

n　　　　　≤1000 　　≤10000 　　≤10^5　　　≤10^6　　　　　≤10^6

题解

Method1：平衡树

这题要动态维护排名，很容易想到平衡树（根据两个关键字维护排序二叉树）

实现：

0.初始化

(1)定义node表示状态，包含AC数目，罚时两个成员，建立平衡树

struct node{
    int ac,fine;
    node(){
        ac=fine=;
    }
    node(int x,int y){
        ac=x;
        fine=y;
    }
    friend inline bool operator<(node x,node y){
        if(x.ac!=y.ac)
            return x.ac>y.ac;
        return x.fine<y.fine;
    }
}key[MAXN],A[MAXN];

1.更新

查找原状态并删除（A是按照编号查询的备份状态），更新状态并插入

if(A[ii].ac)
    del(A[ii]);
A[ii].ac++;
A[ii].fine+=jj;
ins(A[ii]);

2.查询排名

直接查找find的排名即可

last=find(A[ii]);
printf("%d\n",last);

splay代码（因为我写的splay常数极大，TLE了）

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int INF=1e9+,MAXN=1e5+;
 struct node{
     int ac,fine;
     node(){
         ac=fine=;
     }
     node(int x,int y){
         ac=x;
         fine=y;
     }
     friend inline bool operator<(node x,node y){
         if(x.ac!=y.ac)
             return x.ac>y.ac;
         return x.fine<y.fine;
     }
     friend inline bool operator==(node x,node y){
         return x.ac==y.ac&&x.fine==y.fine;
     }
 }key[MAXN],A[MAXN];
 int cnt[MAXN],ch[MAXN][],siz[MAXN],f[MAXN];
 int root,sz;
 inline void clear(int x){
     key[x].ac=key[x].fine=cnt[x]=ch[x][]=ch[x][]=siz[x]=f[x]=;
 }
 inline int get(int x){
     return x==ch[f[x]][];
 }
 inline void upd(int x){
     if(x){
         siz[x]=cnt[x];
         if(ch[x][]){
             siz[x]+=siz[ch[x][]];
         }
         if(ch[x][]){
             siz[x]+=siz[ch[x][]];
         }
     }
 }
 inline void rotate(int x){
     int fa=f[x],gf=f[fa],which=get(x);
     ch[fa][which]=ch[x][which^];
     f[ch[fa][which]]=fa;
     ch[x][which^]=fa;
     f[fa]=x;
     f[x]=gf;
     if(gf){
         ch[gf][ch[gf][]==fa]=x;
     }
     upd(fa);
     upd(x);
 }
 inline void splay(int x){
     for(int fa;(fa=f[x]);rotate(x)){
         if(f[fa]){
             rotate(get(x)==get(fa)?fa:x);
         }
     }
     root=x;
 }
 inline void ins(node x){
     if(!root){
         sz++;
         clear(sz);
         root=sz;
         cnt[sz]=siz[sz]=;
         key[sz]=x;
         return;
     }
     int cur=root,fa=;
     while(){
         if(x==key[cur]){
             cnt[cur]++;
             upd(cur);
             upd(fa);
             splay(cur);
             return;
         }
         fa=cur;
         cur=ch[fa][key[fa]<x];
         if(!cur){
             clear(++sz);
             f[sz]=fa;
             cnt[sz]=siz[sz]=;
             ch[fa][key[fa]<x]=sz;
             key[sz]=x;
             upd(fa);
             splay(sz);
             return;
         }
     }
 }
 inline int find(node x){
     int cur=root,ret=;
     while(){
         if(x<key[cur]){
             cur=ch[cur][];
         }else{
             ret+=(ch[cur][]?siz[ch[cur][]]:);
             if(key[cur]==x){
                 splay(cur);
                 return ret;/*return ret+1*/
             }
             ret+=cnt[cur];
             cur=ch[cur][];
         }
     }
 }
 inline node findx(int x){
     int cur=root;
     while(){
         if(ch[cur][]&&x<=siz[ch[cur][]]){
             cur=ch[cur][];
         }else{
             int tmp=(ch[cur][]?siz[ch[cur][]]:)+cnt[cur];
             if(x<=tmp){
                 return key[cur];
             }
             x-=tmp;
             cur=ch[cur][];
         }
     }
 }
 inline int pre(){
     int cur=ch[root][];
     while(ch[cur][]){
         cur=ch[cur][];
     }
     return cur;
 }
 inline int nxt(){
     int cur=ch[root][];
     while(ch[cur][]){
         cur=ch[cur][];
     }
     return cur;
 }
 inline void del(node x){
     find(x);
     if(cnt[root]>){
         cnt[root]--;
         upd(root);
         return;
     }
     if(!ch[root][]&&!ch[root][]){
         clear(root);
         root=;
         return;
     }
     if(!ch[root][]){
         int old=root;
         root=ch[root][];
         f[root]=;
         clear(old);
         return;
     }
     if(!ch[root][]){
         int old=root;
         root=ch[root][];
         f[root]=;
         clear(old);
         return;
     }
     int old=root,p=pre();
     splay(p);
     ch[root][]=ch[old][];
     f[ch[old][]]=root;
     clear(old);
     upd(root);
 }
 int Task;
 int N;
 unsigned int M,seed,last=;
 inline unsigned int randNum() {
     seed=seed*+last;
     return seed%M+;
 }
 int main(){
     scanf("%d",&Task);
     while(Task--){
         scanf("%d%d%d",&M,&N,&seed);
         root=sz=;
         memset(A,,sizeof(A));
         memset(cnt,,sizeof(cnt));
         memset(ch,,sizeof(ch));
         memset(siz,,sizeof(siz));
         memset(f,,sizeof(f));
         for(int i=;i<=N;i++){
             int ii=randNum(),jj=randNum();
             if(A[ii].ac)
                 del(A[ii]);
             A[ii].ac++;
             A[ii].fine+=jj;
             ins(A[ii]);
             last=find(A[ii]);
             printf("%d\n",last);
         }
     }
     return ;
 }

splay不够快，但又不会别的算法，怎么办？用红黑树rb_tree！

rb_tree代码太长，不会写怎么办？用平板电视pbds！

rb_tree代码

 #include<bits/stdc++.h>
 #include <ext/pb_ds/tree_policy.hpp>
 #include <ext/pb_ds/assoc_container.hpp>
 using namespace __gnu_pbds;
 using namespace std;
 typedef long long LL;
 const int MAXN=1e5+;
 const LL INF=1.5e14,UNIT=1e7;
 struct node{
     int ac,order;
     LL fine;
     node(){ ac=fine=order=; }
     node(int x,int y,int z){ ac=x; fine=y; order=z; }
     friend bool operator<(node x,node y){
         if(x.ac!=y.ac)
             return x.ac>y.ac;
         if(x.fine!=y.fine)
             return x.fine<y.fine;
         return x.order<y.order;
     }
 };
 tree<node,null_type,less<node>,rb_tree_tag,tree_order_statistics_node_update> q;
 int Task;
 int N;
 unsigned M,seed,last=;
 inline unsigned int randNum() {
     seed=seed*+last;
     return seed%M+;
 }
 int ac[MAXN];
 LL fine[MAXN];
 int main(){
     scanf("%d",&Task);
     while(Task--){
         scanf("%d%d%d",&M,&N,&seed);
         q.clear();
         memset(ac,,sizeof(ac));
         memset(fine,,sizeof(fine));
         for(unsigned int i=;i<=M;i++){
             q.insert(node(,fine[i],i));
         }
         for(int i=;i<=N;i++){
             unsigned int ii=randNum();
             unsigned long long jj=randNum();
             q.erase(node(ac[ii],fine[ii],ii));
             ac[ii]++;
             fine[ii]+=jj;
             q.insert(node(ac[ii],fine[ii],ii));
             last=q.order_of_key(node(ac[ii],fine[ii],));
             printf("%d\n",last);
         }
     }
     return ;
 }

Method2：权值线段树

本题有两个关键字，并且第一关键字AC数量非常小，我们可以用一个树状数组维护第一关键字的前缀和

对于第二关键字，我们可以对于每一个第一关键字建一棵权值线段树统计数量，递归查找前缀和

具体实现过程略，直接贴zhousuyu大佬的代码

 #include <cstdio>
 #include <algorithm>
 using namespace std;
 #define ui unsigned int
 const int N = ;
 int Case, n, m, a[N], b[N], c[N], ls[N * ], rs[N * ], sum[N * ], rt[N], tot, lst = ;
 ui seed;
 ui rng() {
     seed = seed *  + lst;
     return seed % m + ;
 }
 void modify(int &x, int l, int r, int p, int v) {
     if (!x)
         x = ++tot, ls[x] = rs[x] = sum[x] = ;
     sum[x] += v;
     if (l == r)
         return;
     int mid = l + r >> ;
     p <= mid ? modify(ls[x], l, mid, p, v) : modify(rs[x], mid + , r, p, v);
 }
 int query(int x, int l, int r, int p) {
     if (l == r)
         return sum[x];
     int mid = l + r >> ;
     return p <= mid ? query(ls[x], l, mid, p) : sum[ls[x]] + query(rs[x], mid + , r, p);
 }
 void mdf(int x, int v) {
     while (x) c[x] += v, x ^= x & -x;
 }
 int qry(int x) {
     int s = ;
     while (x < N) s += c[x], x += x & -x;
     return s;
 }
 int main() {
     scanf("%d", &Case);
     while (Case--) {
         scanf("%d%d%u", &m, &n, &seed);
         for (int i = ; i < N; ++i) a[i] = b[i] = c[i] = rt[i] = ;
         tot = ;
         for (int i = ; i <= n; ++i) {
             int x = rng(), y = rng();
             if (a[x])
                 modify(rt[a[x]], , N, b[x], -), mdf(a[x], -);
             ++a[x];
             b[x] += y;
             modify(rt[a[x]], , N, b[x], );
             mdf(a[x], );
             printf("%d\n", lst = query(rt[a[x]], , N, b[x] - ) + qry(a[x] + ));
         }
     }
     return ;
 }