KYOCERA Programming Contest 2021（AtCoder Beginner Contest 200）题解

哦淦我已经菜到被ABC吊打了。

A - Century

首先把当前年份减去$1$，对应的世纪也减去$1$，然后我们就发现第$0$到$99$年对应第$0$世纪，第$100$到$199$年对应第$1$世纪，以此类推。

答案就是$\lfloor \frac {N-1} {100} \rfloor$。这里$\lfloor x \rfloor$表示不超过$x$的最大整数。

#include<bits/stdc++.h>

using namespace std;

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    int n;

    cin>>n;

    cout<<(n-1)/100+1<<endl;

    return 0;

}

B - 200th ABC-200

乍一看答案会很大，然后爆long long。

其实假如当前数不是$200$的倍数的时候，把它后面连接上$200$，结果一定是$200$的倍数，因为$1000$一定是$200$的倍数。

所以答案其实不会很大，最多就是$976555175781$（$N=99999, K=20$）。

然后暴力做就好了。

#include<bits/stdc++.h>

using namespace std;

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    long long n;

    int k;

    cin>>n>>k;

    while(k){

        if(n%200==0)n/=200,k--;

        else n=n*1000+200,k--;

    }

    cout<<n;

    return 0;

}

C - Ringo's Favorite Numbers 2

假如两个数相减是$200$的倍数，他们对$200$取模后，得到的结果一定相同。

然后就用前缀和记录在当前的位置之前有多少个数对$200$取模得到的结果和这个数对$200$取模的结果相同，并且把这个加入答案中就可以了。

只有我一开始以为差一定要是非负数然后被坑了么。

#include<bits/stdc++.h>

using namespace std;

int n,a[200005],c[205];

long long ans;

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n;

    for(int i=1;i<=n;i++){

        cin>>a[i];

        ans+=c[a[i]%200];

        c[a[i]%200]++;

    }

    cout<<ans;

    return 0;

}

D - Happy Birthday! 2

首先还是把所有的数都对$200$取模。

然后我们可以想出来一种DP的状态表示方法：$f_{i,j}$表示已经处理了前$i$个数，选出来的$B$序列和$C$序列的差对$200$取模等于$j$。

这种状态的转移，可以枚举当前的数是放进$B$中还是$C$中，亦或是两个序列都不放。输出方案也只需要记录上一个状态的$j$，然后反着操作一遍就好了。

但是它有一个问题，就是不能保证两个序列都是非空的。

我们可以再开一维，记录两个序列当中是不是有元素了：$f_{i,j,k}$表示已经处理了前$i$个数，选出来的$B$序列和$C$序列的差对$200$取模等于$j$，$k$以子集的位掩码的形式记录两个序列是否非空。

子集的位掩码这个表述非常有点奇怪，具体来说就是：

$k=0$表示两个序列都是空的。
$k=1$表示一个序列都是空的。
$k=2$表示另一个序列都是空的。
$k=3$表示两个序列都是非空的。

（“一个”和“另一个”的表述是因为这不重要，我就懒得想了）

然后为了输出方案还要记录上一个状态的$k$是多少。

#include<bits/stdc++.h>

using namespace std;

int n,a[205],g[205][205][4],h[205][205][4];

bool f[205][205][4];

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n;

    for(int i=1;i<=n;i++){

        cin>>a[i];

        a[i]%=200;

    }

    f[0][0][0]=1;

    for(int i=1;i<=n;i++){

        f[i][0][0]=1;

        for(int j=0;j<200;j++){

            for(int k=1;k<=3;k++){

                if(f[i-1][(j+a[i])%200][k&1]){

                    f[i][j][k]=1;

                    g[i][j][k]=-1;

                    h[i][j][k]=k&1;

                }

                if(f[i-1][(j+a[i])%200][k]){

                    f[i][j][k]=1;

                    g[i][j][k]=-1;

                    h[i][j][k]=k;

                }

                if(f[i-1][j][k]){

                    f[i][j][k]=1;

                }

                if(f[i-1][(j-a[i]+200)%200][k&2]){

                    f[i][j][k]=1;

                    g[i][j][k]=1;

                    h[i][j][k]=k&2;

                }

                if(f[i-1][(j-a[i]+200)%200][k]){

                    f[i][j][k]=1;

                    g[i][j][k]=1;

                    h[i][j][k]=k;

                }

            }

        }

    }

    if(!f[n][0][3]){

        cout<<"NO";

        return 0;

    }

    int x=n,y=0,z=3;

    cout<<"YES\n";

    vector<int> u,v;

    while(x){

        if(g[x][y][z]==1){

            u.emplace_back(x);

            z=h[x][y][z];

            y=(y-a[x]+200)%200;

        }else if(g[x][y][z]==-1){

            v.emplace_back(x);

            z=h[x][y][z];

            y=(y+a[x])%200;

        }

        x--;

    }

    reverse(u.begin(),u.end());

    cout<<u.size()<<' ';

    for(int i:u)cout<<i<<' ';

    cout<<'\n';

    reverse(v.begin(),v.end());

    cout<<v.size()<<' ';

    for(int i:v)cout<<i<<' ';

    return 0;

}

E - Patisserie ABC 2

这里我们可以想到先枚举三种属性的和是多少。然后我们可以定义$tot(m)$，表示和为$m$的时候，一共有多少种组合方式。

然后由于每个属性的值都是$1$到$n$的限制，又到了激动人心的分类讨论环节。

首先我们把第一属性的值叫做$i$，那么后两个属性的和就是$m-i$。

$2\leq m-i\leq n+1$：那么第二属性的取值范围就是$1$到$m-i-1$，答案就是$\sum_{\max(m-n-1,1)}^{\min(n,m-2)}m-i-1$
$n+2\leq m-i\leq 2n$：那么第二属性的取值范围就是$m-i-n$到$n$，答案就是$\sum_{\max(1,m-2*n)}^{\min(n,m-n-2)}2n-(m-i)+1$

那么：

\[tot(i)=\sum_{\max(m-n-1,1)}^{\min(n,m-2)}(m-i-1)+\sum_{\max(1,m-2*n)}^{\min(n,m-n-2)}(2n-(m-i)+1)
\]

然后就可以枚举$m$，快速的削减$k$的值，直到$k$小于等于$tot(m)$了，这时候我们就枚举第一属性$i$，然后根据上文的分类讨论计算第二属性和第三属性的取值即可（同样是先快速削减$k$，然后$k$小于等于当前第一属性对应取值种类数时输出答案）。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int n;

ll k;

ll sum(int l,int r,int lv,int rv){

    return (ll)(lv+rv)*(r-l+1)/2;

}

ll tot(int m){

    ll res=0;

    if(m<=2*n+1){

        int l=max(1,m-n-1),r=min(n,m-2);

        res+=sum(l,r,m-l-1,m-r-1);

    }

    if(m>n+2){

        int l=max(1,m-2*n),r=min(n,m-n-2);

        res+=sum(l,r,2*n-(m-l)+1,2*n-(m-r)+1);

    }

    return res;

}

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>n>>k;

    for(int m=3;m<=3*n;m++){

        if(k>tot(m)){

            k-=tot(m);

            continue;

        }

        for(int i=1;i<=n;i++)if(m-i<=n*2){

            if(m-i<=n+1){

                if(k>m-i-1){

                    k-=m-i-1;

                    continue;

                }

                cout<<i<<' '<<k<<' '<<m-i-k;

                return 0;

            }else{

                if(k>2*n-(m-i)+1){

                    k-=2*n-(m-i)+1;

                    continue;

                }

                cout<<i<<' '<<m-i-n-1+k<<' '<<n+1-k;

                return 0;

            }

        }

    }

    return 0;

}

F - Minflip Summation

由于我是看了题解才把这题做出来的，所以就照着题解翻译吧（还好意思讲）。

假如$S$不包含`?`同时$K=1$的解法

我们把所有左右相邻的，一个是$0$一个是$1$的位置（也就是$S_i\neq S_{i+1}$的位置$i$）都数出来（比如10100能数出来$3$个）。

为了叙述方便，我们把它叫做“切换位置”（毕竟是从$0$切换到$1$或者从$1$切换到$0$）。

然后发现一次操作，最多把它减少$2$（选择两个切换位置去操作），也可以减少$1$（选择一个切换位置，和一个开头/结尾）。

那么假如数出来$D$个位置，就需要$\lfloor \frac D 2 \rfloor$次操作解决。

这道题的解法

然后对于所有的这样的位置，我们记录他们的总和是$A$：（主要是从AtCoder的题解上搬的，但是修了一点小锅）

\[A = 2^{Kq} \times ( ( K \times \displaystyle \sum_{i=1}^{|S|-1} f(S_i,S_{i+1}) ) + (K-1) \times f(S_1,S_{|S|}))
\]

\[\begin{eqnarray}
f(a,b)
=
\begin{cases}
\frac{1}{2} & \text{(if at least one of }a\text{ and }b\text{ is ?)} \\
1 & \text{(if neither }a\text{ nor }b\text{ is ? and }a\neq b\text{)} \\
0 & \text{(if neither }a\text{ nor }b\text{ is ? and }a = b\text{)} \\
\end{cases}
\end{eqnarray}
\]

然后答案似乎应该是$\frac A 2$，不过还有一点问题：假如说一个串数出来奇数个切换位置，这种算法对于这个串会不会少算了半次操作？

我们可以发现，对于有奇数个切换位置的串，多添加一个切换位置后答案相同。

然后假如给$A$添加上这些串的个数，答案就是$\frac A 2$了。

这些串有一个性质：他们的开头和结尾，是不同的（毕竟切换了奇数次）。

然后这些串的个数就是$2^{Kq} \times f(S_1,S_{|S|})$。

然后答案就是$\frac {A+2^{Kq} \times f(S_1,S_{|S|})} 2$，也就是：

\[2^{Kq} \times K \times \sum_{i=1}^{|S|} f(S_i,S_{i+1})
\]

（特别地，这里把$S_{|S|+1}$看作是$S_1$）

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int mod=1e9+7;

const int inv2=5e8+4;

ll qpow(ll a,ll n){

    ll res=1;

    while(n){

        if(n&1)res=res*a%mod;

        a=a*a%mod;

        n>>=1;

    }

    return res;

}

int n,m,k,ans;

char s[100005];

int main(){

    ios::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    cin>>s>>k;

    n=strlen(s);

    if(n*k==1){cout<<0;return 0;}

    for(int i=0;i<n;i++)m+=s[i]=='?';

    m=qpow(2,(ll)k*m)*inv2%mod*k%mod;

    for(int i=0;i<n;i++){

        if(s[i]=='?'||s[(i+1)%n]=='?')ans=(ans+m)%mod;

        else if(s[i]!=s[(i+1)%n])ans=(ans+m*2%mod)%mod;

    }

    cout<<(ll)ans*inv2%mod;

    return 0;

}