Codeforces Goodbye 2018

Posted 2021-02-08 Winniechen

Goodbye 2018

• 可能是我太菜考试的时候出不了$E$
• 可能是我太菜考试的时候调不出$F$
• 所以转化为手速场之后手速还上不去.jpg

A

模拟题意...

#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int main()
{
    int y,b,r,ans=1<<30;
    scanf("%d%d%d",&y,&b,&r);
    ans=min(r-2,min(b-1,y));
    printf("%d
",ans*3+3);
}

B

因为一定有，所以就一定是一个位置。

然后就相当于是给你$2 imes n$个点，两两匹配的中点在同一个点的方案。

然后就直接横坐标纵坐标求平均数即可.jpg

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <bitset>
using namespace std;
#define ll long long
int n,x,y;ll a,b;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n<<1;i++)
    {
        scanf("%d%d",&x,&y);
        a+=x,b+=y;
    }
    printf("%lld %lld
",a/n,b/n);
}

C

推一下式子就完事了.jpg

可以发现，跳的步数一定是$n$的约数，然后发现构成的节点是等差数列。

然后发现，直接暴力求即可...

最后需要排个序...

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <bitset>
using namespace std;
#define ll long long
ll n,ans[1000005];
int tot;
int main()
{
    scanf("%lld",&n);
    for(ll i=1;i*i<=n;i++)
    {
        if(n%i==0)
        {
            ans[++tot]=(2+n-i)*(n/i)>>1;
            ans[++tot]=(2+n-(n/i))*i>>1;
        }
    }
    sort(ans+1,ans+tot+1);
    tot=unique(ans+1,ans+tot+1)-ans-1;
    for(int i=1;i<=tot;i++)printf("%lld ",ans[i]);puts("");
}

D

比较好玩的数数题.jpg

（可能我的数数题也就是这么菜鸡吧.jpg

OEIS了一发，并没有.jpg

然后我们考虑，答案一定会长成这个样子：$n imes n!-sumlimits_{i=1}^{n-1}frac{n!}{i!}$

表达的含义很简单，就是对于两个字典序相近的排列，假设前一个字典序结尾有$K$位是递减的，那么说明，下次变动的时候，会有$K+1$为被改掉了，其他的位没有动。

然后可以发现，其他的$n-K$位都能依旧构成一个满足要求的序列，而剩下的$K+1$位都不能满足...

对于这样的前缀，一共有$frac{n!}{k!}$个，所以答案就是$n imes n!-sumlimits_{i=1}^{n-1}frac{n!}{i!}$

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define N 1000010
#define ll long long
#define mod 998244353
int n;
ll f[N],g[N],ans,inv[N];
inline ll q_pow(ll x,int n){ll ret=1;for(;n;n>>=1,x=x*x%mod)if(n&1)ret=ret*x%mod;return ret;}
int main()
{
    scanf("%d",&n);
    f[0]=1ll;
    for(int i=1;i<=n;i++)
        f[i]=(f[i-1]*i)%mod,inv[i]=q_pow(f[i],mod-2);
    for(int i=1;i<=n;i++)g[i]=(f[n]*inv[n-i])%mod;
    (ans+=f[n])%=mod;
    for(int i=2;i<n;i++)(ans+=(g[n-i]*(f[i]-1+mod))%mod)%=mod;
    printf("%lld
",ans);
    return 0;
}

证明好难.jpg

E

下次题目中的蓝字一定要点开，然后翻译一下，说不定就有题解...

我们发现，对于答案方案来说，一定是满足连续性的，也就是说$K,K+4$是答案，那么$K+2$也一定是答案.jpg

原因很简单，就是说，可以让前面的某俩人互相匹配上，就不用和最后一个人匹配了...

并且可以发现，对于这样的匹配变动，在找到一个最小的满足答案要求的$a_{n+1}$的时候，就不能再找到一个新的变动了

然后就是如何找到答案...

然后那个蓝字中有这样的一个式子.jpg

对于图，满足：对于任意一个$k$满足$sumlimits_{i=1}^kd_i le k imes(k-1)+sumlimits_{i=k+1}^nmin(d_i,k)$，并且$sumlimits_{i=1}^nd_i$为偶数...

那么我们就可以维护了.jpg

先二分答案，然后考虑如何验证...

对于一个$d_{n+1}$，如果它在排序后位于$t$这个位置，那么如果最先不满足条件的位置$K< t$，说明这个$d_i$太小了...

如果最先不满足跳脚的位置$Kge t$，那么说明这个$d_i$太大了。

所以根据这个就可以找到最大值和最小值了...

然后就完事了...

至于怎么$O(n)$验证：插入排序...

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <iostream>
#include <bitset>
using namespace std;
#define N 500005
#define ll long long
int a[N],n,d[N],pos[N];ll s[N];
int check(int x)
{
    int flg=0;d[n+1]=-1;
    for(int i=1,j=0;i<=n;i++)
    {
        if(flg||a[i]>=x)d[++j]=a[i];
        else flg=++j,d[j]=x,i--;
    }
    if(!flg)d[n+1]=x,flg=n+1;
    s[0]=0;
    for(int i=1;i<=n+1;i++)s[i]=d[i]+s[i-1];//,printf("%d ",d[i]);;puts("");
    for(int i=n+1,now=1;i;i--)
        while(now<=n+1&&d[i]>now)pos[now++]=i;
    for(int k=1;k<=n+1;k++)
    {
        ll tmp=s[k]-(ll)k*(k-1);
        tmp-=(ll)k*max(pos[k]-k,0);tmp-=s[n+1]-s[pos[k]];
        // printf("%d %d %d %lld
",x,k,pos[k],tmp);
        if(tmp>0)return k<flg?-1:1;
    }return 0;
}
int main()
{
    scanf("%d",&n);int flg=0;
    for(int i=1;i<=n;i++)scanf("%d",&a[i]),flg^=(a[i]&1);
    sort(a+1,a+n+1);reverse(a+1,a+n+1);
    int l=0,r=(n>>1)+1;
    while(l<r)
    {
        int m=(l+r)>>1;
        if(check((m<<1)|flg)!=-1)r=m;
        else l=m+1;
    }
    if(check((l<<1)|flg))return puts("-1"),0;
    int ans=l;r=(n>>1)+1;
    while(l<r)
    {
        int m=(l+r)>>1;
        // printf("%d %d %d %d
",l,m,r,check((m<<1)|flg));
        if(!check((m<<1)|flg))l=m+1;
        else r=m;
    }l--;
    ans=(ans<<1)|flg,l=(l<<1)|flg;
    for(int i=ans;i<=l;i+=2)printf("%d ",i);
}

F

通过分析性质可以发现，能在水里多游绝不在草上多走...能在草上走，绝不在水里多游...能在草上飞，就不在水里飞...

然后就变成了增加两个位置的长度了...

分别是：第一块和第一块水...

然后就模拟就好了...

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
#define N 100005
#define ll long long
int n,flg;ll a[N],now,ans,res,tmp;
char s[N];
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%lld",&a[i]);scanf("%s",s+1);
    flg=1;
    for(int i=1;i<=n;i++)
    {
        if(s[i]=='W'&&s[flg]=='G')flg=i;
        if(s[i]=='L')now-=a[i];
        else now+=a[i];
        if(now<=0)a[flg]-=now,now=0;
    }
    now=0;
    for(int i=1;i<=n;i++)
    {
        ll tmp=a[i];
        if(s[i]=='W')now+=tmp,ans+=2*tmp;
        if(s[i]=='G')
        {
            ll tnp=min(tmp,now);
            now-=tnp,ans+=2*tnp;
            ans+=3*(tmp-tnp);
        }
        if(s[i]=='L')
        {
            ll tnp=min(tmp,now);
            now-=tnp,tmp-=tnp,ans+=2*tnp;
            ans+=3*tmp;
        }
    }
    printf("%lld
",ans);
}
//sdasdasdas

剩下的还不会，回头补题吧QaQ