2020 CCF CSP-J2(直播获奖)

NOI2130 即将举行。

为了增加观赏性，CCF 决定逐一评出每个选手的成绩，并直播即时的获奖分数线。

本次竞赛的获奖率为 w%，即当前排名前 w% 的选手的最低成绩就是即时的分数线。

更具体地，若当前已评出了 p 个选手的成绩，则当前计划获奖人数为 max(1,⌊p×w%⌋)，其中 w 是获奖百分比，⌊x⌋ 表示对 x 向下取整，max(x,y) 表示 x 和 y 中较大的数。

如有选手成绩相同，则所有成绩并列的选手都能获奖，因此实际获奖人数可能比计划中多。

作为评测组的技术人员，请你帮 CCF 写一个直播程序。

输入格式
第 1 行两个正整数 n,w。分别代表选手总数与获奖率。

第 2 行有 n 个非负整数，依次代表逐一评出的选手成绩。

输出格式
只有一行，包含 n 个非负整数，依次代表选手成绩逐一评出后，即时的获奖分数线。

相邻两个整数间用一个空格分隔。

数据范围
测试点编号 n
1∼3 =10
4∼6 =500
7∼10 =2000
11∼17 =10000
18∼20 =100000
对于所有测试点，每个选手的成绩均为不超过 600 的非负整数，获奖百分比 w 是一个正整数且 1≤w≤99。

在计算计划获奖人数时，如用浮点类型的变量（如 C/C++中的 float、double，Pascal 中的 real、double、extended 等）存储获奖比例 w，则计算 5×60% 时的结果可能为 3.000001，也可能为 2.999999，向下取整后的结果不确定。因此，建议仅使用整型变量，以计算出准确值。

输入样例1：
10 60
200 300 400 500 600 600 0 300 200 100
输出样例1：
200 300 400 400 400 500 400 400 300 300
样例1解释
已评测选手人数 1 2 3 4 5 6 7 8 9 10

计划获奖人数 1 1 1 2 3 3 4 4 5 6

已评测选手的分 200 300 400 500 600 600 600 600 600 600
数从高到低排列 200 300 400 500 600 600 600 600 600
200 300 400 500 500 500 500 500
200 300 400 400 400 400 400
200 300 300 300 300 300
200 200 300 300 300
0 200 200 200
0 200 200
0 100
0
注意，在第 9 名选手的成绩评出之后，计划获奖人数为 5 人，但由于有并列，因此实际会有 6 人获奖。

输入样例2：
10 30
100 100 600 100 100 100 100 100 100 100
输出样例2：
100 100 600 600 600 600 100 100 100 100

思路：
维护区间里面的值 得到分数合格的 使用线段树 直接树上二分来找

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 2401; // 四倍节点数

int n, w;
struct Tree
{
    int l, r, v;
}tr[N];

void pushup(int u)
{
    tr[u].v = tr[u << 1].v + tr[u << 1 | 1].v;
}

void build(int u, int l, int r)
{
    tr[u].l = l, tr[u].r = r;
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
}

void modify(int u, int x)//树上二分
{
    if (tr[u].l == x && tr[u].r == x) tr[u].v ++ ;
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x);
        else    modify(u << 1 | 1, x);
        pushup(u);
    }
}

int kth(int u, int k)
{
    if (tr[u].l == tr[u].r) return tr[u].r;
    if (tr[u << 1].v >= k) return kth(u << 1, k);
    return kth(u << 1 | 1, k - tr[u << 1].v);
}

int main()
{
    scanf("%d%d", &n, &w);
    build(1, 0, 600); // 线段树就不用考虑插入 0 了
    for (int i = 1; i <= n; i ++ )
    {
        int x;
        scanf("%d", &x);
        modify(1, x);
        printf("%d ", kth(1, i - max(1, i * w / 100) + 1));
    }
    return 0;
}

第二种：
暴力枚举 开一个数组纪录该分数有多少人 每一次插入 纪录在数组里面 然后遍历一次 从 600 - 0 开始枚举 时间复杂度（600 * n）

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 605;
int score[N];
int p , w;

int main()
{
    cin >> p >> w ;
   
    for(int i =1 ; i <= p ; i++)
    {     int t;
        cin >> t;
        score[t]++;
       int res  = max(1,i * w / 100);//合格人数是多少
       //排序去找 从大往下找
       for(int  j = 600 ; j >=0 ; j--)
       {
           
           if((res -= score[j]) <= 0) 
           {
               cout << j <<' ';
               break;
           }
       }
       
    }
return 0;
  
}