牛客周赛26

牛客周赛 Round 26

A 小红的整数操作

数学，模数相同的会再同一组里

#include <bits/stdc++.h>

using namespace std;
const int N = 1e5 + 10;
int a[N];
map<int,int> m;
int main()
{
    int n , k;
    cin >> n >> k;

    for(int i = 0 ; i < n ; i ++){
        cin >> a[i];
        m[a[i] % k] ++;
    } 
    int ans = -1;
    for(auto x : m){
        ans = max(ans , x.second);
    }
    cout << ans << endl;
}

B 小红的01串

操作不会改变奇偶性，所以直接根据奇偶性判断

#include <bits/stdc++.h>

using namespace std;
const int N = 1e5 + 10;
int a[N];
void solve()
{
    string s;
    cin >> s;
    int c1 = count(s.begin() , s.end() , '0');
    int c2 = count(s.begin() , s.end() , '1');
    if(c1 == 0 || c2 == 0){
        cout << "Yes\n";
        return ;
    }
    if(c1 % 2 == 0 || c2 % 2 == 0){
        cout << "Yes\n";
        return ;
    }
    cout << "No\n";
}
int main()
{
    int T;
    cin >> T;
    while(T --){
        solve();
    }
    return 0;
}

C 小红闯沼泽地

dp[i][j]表示到i,j的最小步数，因为要从i,j+1转移过来，因此要反着遍历一遍

#include <bits/stdc++.h>

using namespace std;
const int N = 2e3 + 10;
int a[N][N] , d[N][N];
void solve()
{
    int n , m;
    cin >> n >> m;
    memset(a , 2 , sizeof(a));
    memset(d , 0x3f , sizeof(d));
    for(int i = 1 ; i <= n ; i ++){
        for(int j = 1 ; j <= m ; j ++){
            cin >> a[i][j];
        }
    }
    d[1][1] = 0;
    for(int i = 1 ; i <= n ; i ++){
        for(int j = 1 ; j <= m ; j ++){
            if(a[i][j] == a[i - 1][j]){
                d[i][j] = min(d[i][j] , d[i - 1][j] + 1);
            }else d[i][j] = min(d[i][j] , d[i - 1][j] + 2);
            if(a[i][j] == a[i][j - 1]){
                d[i][j] = min(d[i][j] , d[i][j - 1] + 1);
            }else d[i][j] = min(d[i][j] , d[i][j - 1] + 2);
        }
        for(int j = m ; j >= 1 ; j --){
            if(a[i][j] == a[i][j + 1]){
                d[i][j] = min(d[i][j] , d[i][j + 1] + 1);
            }else d[i][j] = min(d[i][j] , d[i][j + 1] + 2);
        }
    }
    cout << d[n][m];
}
int main()
{
    int T = 1;
    while(T --){
        solve();
    }
    return 0;
}

D 小红的漂亮串（二）

状态机dp

#include <bits/stdc++.h>

using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
long long dp[N][7]; // 第一维表示当前字符串长度，第二维表示 7 种状态 
void pre() 
{
    dp[1][0] = 25; // 状态0：表示当前没有一个 red，且当前位置不是 r 的种类数
    dp[1][1] = 1; // 状态1：表示当前没有一个 red，且当前位置是 r 的种类数 
    dp[1][2] = 0; // 状态2：表示当前没有一个 red，且当前位置是 re 的种类数 
    dp[1][3] = 0; // 状态3：表示到当前位置为止有一个 red，且当前位置是非后续状态的种类数 
    dp[1][4] = 0; // 状态4：表示当前有一个 red，且当前位置是 r 的种类数 
    dp[1][5] = 0; // 状态5：表示当前有一个 red，且当前位置是 re 的种类数 
    dp[1][6] = 0; // 状态6：表示到当前位置为止有两个 red 的种类数 
}
void solve()
{
    int n;
    cin >> n;
    pre();
    for(int i = 2; i <= n; i++)
    {
        // 状态0 可以从 状态0加上非r字母 转移而来：dp[i-1][0]*25 
        // 状态0 可以从 状态1加上非r非e字母 转移而来：dp[i-1][1]*24 
        // 状态0 可以从 状态2加上非r非d字母 转移而来：dp[i-1][2]*24 
        dp[i][0] = ((dp[i-1][0]*25)%mod + (dp[i-1][1]*24)%mod + (dp[i-1][2]*24)%mod)%mod;
         
        // 状态1 可以从 状态0加上r字母 转移而来：dp[i-1][0] 
        // 状态1 可以从 状态1加上r字母 转移而来：dp[i-1][1] 
        // 状态1 可以从 状态2加上r字母 转移而来：dp[i-1][2] 
        dp[i][1] = (dp[i-1][0]%mod + (dp[i-1][1])%mod + (dp[i-1][2])%mod)%mod;
         
        // 状态2 可以从 状态1加上e字母 转移而来：dp[i-1][1] 
        dp[i][2] = dp[i-1][1]%mod;
         
        // 状态3 可以从 状态2加上d字母 转移而来：dp[i-1][2] 
        // 状态3 可以从 状态3加上非r字母 转移而来：dp[i-1][3]*25 
        // 状态3 可以从 状态4加上非r非e字母 转移而来：dp[i-1][4]*24 
        // 状态3 可以从 状态5加上非r非d字母 转移而来：dp[i-1][5]*24 
        dp[i][3] = (dp[i-1][2]%mod + (dp[i-1][3]*25)%mod + (dp[i-1][4]*24)%mod + (dp[i-1][5]*24)%mod)%mod;
         
        // 状态4 可以从 状态3加上r字母 转移而来：dp[i-1][3] 
        // 状态4 可以从 状态4加上r字母 转移而来：dp[i-1][4] 
        // 状态4 可以从 状态5加上r字母 转移而来：dp[i-1][5] 
        dp[i][4] = (dp[i-1][3]%mod + dp[i-1][4]%mod + dp[i-1][5]%mod)%mod;
         
        // 状态5 可以从 状态4加上e字母 转移而来：dp[i-1][4] 
        dp[i][5] = dp[i-1][4]%mod;
         
        // 状态6 可以从 状态5加上d字母 转移而来：dp[i-1][5] 
        // 状态6 可以从 状态6加上任意字母 转移而来：dp[i-1][6]*26 
        dp[i][6] = (dp[i-1][5]%mod + (dp[i-1][6]*26)%mod)%mod;
    }
    // 输出长度为 n 时，状态 6（即至少两个 red）的种类数 
    cout << dp[n][6]%mod << endl;
}
int main()
{
    int T = 1;
    while(T --){
        solve();
    }
    return 0;
}

---