[BZOJ5368/Pkusc2018]真实排名

Description
小C是某知名比赛的组织者，该比赛一共有n名选手参加，每个选手的成绩是一个非负整数，定义一个选手的排名是：成绩不小于他的选手的数量（包括他自己）。例如如果3位选手的成绩分别是[1,2,2]，那么他们的排名分别是[3,2,2]。拥有上帝视角的你知道所有选手的实力，所以在考试前就精准地估计了每个人的成绩，设你估计的第iii个选手的成绩为Ai,且由于你是上帝视角，所以如果不发生任何意外的话，你估计的成绩就是选手的最终成绩。但是在比赛当天发生了不可抗的事故（例如遭受到了外星人的攻击），导致有一些选手的成绩变成了最终成绩的两倍，即便是有上帝视角的你也不知道具体是哪些选手的成绩翻倍了，唯一知道的信息是这样的选手恰好有k个。现在你需要计算，经过了不可抗事故后，对于第i位选手，有多少种情况满足他的排名没有改变。由于答案可能过大，所以你只需要输出答案对998244353取模的值即可。

Input
第一行两个正整数n,k
第二行n个非负整数A1..An
1≤k<n≤10^5 ，0≤Ai≤10^9

Output
输出n行，第i行一个非负整数ansi，表示经过不可抗事故后，第i位选手的排名没有发生改变的情况数。

Sample Input
3 2
1 2 3

Sample Output
3
1
2

HNIT
一共有3种情况：(1,2)翻倍，(1,3)翻倍，(2,3)翻倍。
对于第一个选手来说，他的成绩就算翻倍，其他人都不低于他，所以任意情况下他的排名都不会改变。
对于第二个选手来说，如果是(1,2)翻倍，成绩变成(2,4,3)，他的排名变成了第一；
如果是(1,3)翻倍，则成绩变成(2,2,6)，他的排名变成了第三；如果是(2,3)翻倍，则成绩变成(1,4,6)，他的排名还是第二。
所以只有一种情况。
对于第三个选手来说，如果是(1,2)翻倍，他的排名会变成第二，其他情况下都还是第一。

---

没想到居然一遍过！还以为要WA个上万次才过……
这题非常有意思，首先想容斥，然后发现没必要；因为我们可以分两种情况考虑，自己翻倍，或者不翻倍。
首先是自己翻倍的情况，那么只要找出翻倍之后有多少个点也要跟着一起翻倍即可；
不翻倍的话，只要找出有多少个点一定不能翻倍。
所以，一个组合数就可以搞定了~
(ps:代码内有注解)

/*program from Wolfycz*/
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define inf 0x7f7f7f7f
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
inline int read(){
    int x=0,f=1;char ch=getchar();
    for (;ch<'0'||ch>'9';ch=getchar())  if (ch=='-')    f=-1;
    for (;ch>='0'&&ch<='9';ch=getchar())    x=(x<<1)+(x<<3)+ch-'0';
    return x*f;
}
inline void print(int x){
    if (x>=10)     print(x/10);
    putchar(x%10+'0');
}
const int N=1e5,p=998244353;
int fac[N+10],inv[N+10];
int val[N+10],list[N+10],sum[N+10],cnt[N+10];
void prepare(){
    fac[0]=inv[0]=inv[1]=1;
    for (int i=1;i<=N;i++)  fac[i]=1ll*fac[i-1]*i%p;
    for (int i=2;i<=N;i++)  inv[i]=1ll*(p-p/i)*inv[p%i]%p;
    for (int i=1;i<=N;i++)  inv[i]=1ll*inv[i-1]*inv[i]%p;
}
int C(int n,int m){return 1ll*fac[n]*inv[m]%p*inv[n-m]%p;}
int main(){
    prepare();
    int n=read(),k=read();
    for (int i=1;i<=n;i++)  list[i]=val[i]=read();
    sort(list+1,list+1+n);
    int T=unique(list+1,list+1+n)-list-1;
    for (int i=1;i<=n;i++)  val[i]=lower_bound(list+1,list+1+T,val[i])-list;
    for (int i=1;i<=n;i++)  cnt[val[i]]++;
    for (int i=1;i<=n;i++)  sum[i]=sum[i-1]+cnt[i];
    for (int i=1;i<=n;i++){
        int v=list[val[i]],Ans=0,newplace=0,num=0;
        //当前点不翻倍 
        newplace=lower_bound(list+1,list+1+T,(v+1)>>1)-list;//向小的方向
        num=val[i]==newplace?1:sum[val[i]-1]-sum[newplace-1]+1;//统计前面有多少个点不能翻倍
        //和自己相同的其他人是可以翻倍的，翻倍了小于自己的点可以不用统计
        Ans=(Ans+C(n-num,k))%p;
        
        //当前点翻倍 
        newplace=lower_bound(list+1,list+1+T,v<<1)-list;//向大的方向
        num=val[i]==newplace?1:sum[newplace-1]-sum[val[i]-1];
        //统计若自己翻倍的话，有多少个点必须翻倍
        if (num>k)  goto write;//中间的点必须翻倍，如果翻倍人数不够，直接输出之前答案 
        Ans=(Ans+C(n-num,k-num))%p;//除了中间的点，剩下的点随便选 
        write:printf("%d\n",Ans);
    }
    return 0;
}

转载于:https://www.cnblogs.com/Wolfycz/p/9144093.html