Codeforces Round 855 (Div. 3)（A~F）

_dawn°

已于 2023-03-07 16:23:53 修改

阅读量1.4k

点赞数 2

分类专栏： Codeforce补题文章标签：哈希算法算法 c++ Powered by 金山文档

于 2023-03-03 21:31:56 首次发布

本文链接：https://blog.csdn.net/m0_62289613/article/details/129325687

版权

Codeforce补题专栏收录该内容

43 篇文章 0 订阅

订阅专栏

A. Is It a Cat?

定义满足条件的字符串为：其中仅可能含有meow四种字母的大小写，而且相同种类的字母必须挨在一起，四种字母的顺序必须按照meow排列。给出一个字母串，求是否满足条件。

思路：感觉是个很麻烦的模拟。首先把大小写全都转为小写字母，再把相同的字母合并，最后判断一下字母的种类和顺序。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e6 + 5;
int t, n;
std::string s;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> s;
        std::vector<char> vec;
        char c;
        if(s[0] >= 'A' && s[0] <= 'Z')
            vec.push_back((char)(s[0] - 'A' + 'a')), c = (char)(s[0] - 'A' + 'a');
        else
            vec.push_back(s[0]), c = s[0];
        for(int i = 1; i < n; i ++) {
            if(s[i] >= 'A' && s[i] <= 'Z')
                s[i] = (char)(s[i] - 'A' + 'a');
            if(s[i] != c)
                vec.push_back(s[i]), c = s[i];
        }
        if(vec.size() == 4 && vec[0] == 'm' && vec[1] == 'e' && vec[2] == 'o' && vec[3] == 'w')
            std::cout << "YES" << '\n';
        else
            std::cout << "NO" << '\n';
    }
    return 0;
}

B. Count the Number of Pairs

给出一个字符串，对于同一种字母，一个大写一个小写可以凑成一对；给出k次操作，可以将任意一个字母大小写翻转，问给出的字符串中最多可以有多少对字母。

思路：统计字符串中大小写字母的个数，先统计不经过修改可以得到多少串，然后拥挤通过修改可以最多得到多少对即可。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e6 + 5;
int t, n, k;
std::string s;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> k >> s;
        int ans = 0;
        std::unordered_map<char, int> mpl, mpu;
        for(int i = 0; i < n; i ++) {
            if(s[i] >= 'a' && s[i] <= 'z')
                mpl[s[i]] ++;
            else
                mpu[s[i]] ++;
        }
        for(auto [x, y] : mpl) {
            if(y && mpu[x - 'a' + 'A']) {
                ans += std::min(y, mpu[x - 'a' + 'A']);
                mpl[x] -= std::min(y, mpu[x - 'a' + 'A']);
                mpu[x - 'a' + 'A'] -= y, mpu[x - 'a' + 'A'];
            }
        }
        for(auto [x, y] : mpl) {
            if(y >= 2) {
                int res = std::min(k, y / 2);
                ans += res, k -= res, y -= res * 2;
            }
        }
        for(auto [x, y] : mpu) {
            if(y >= 2) {
                int res = std::min(k, y / 2);
                y -= res * 2, ans += res, k -= res;
            }
        }
        std::cout << ans << '\n';
    }
    return 0;
}

C. Powering the Hero

给出一个数组，其中非0的数字可以被存下来，放在一堆中；为0的数可以加上现有的非0数中的一个数。求所有的为0的值，通过修改得到的和最大是多少。

思路：优先队列即可，每次遇到一个非0的数，就将其放进队列中，遇到为0的数就取出队列中最大的数加入答案，并pop出队列，easy版本做法与hard版本相同，时间复杂度O(nlogn)，能过。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e6 + 5;
int t, n;
ll a[N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n;
        std::priority_queue<ll> pq;
        ll ans = 0;
        for(int i = 1; i <= n; i ++) {
            std::cin >> a[i];
            if(a[i])
                pq.push(a[i]);
            if(!a[i] && !pq.empty()) {
                ans += pq.top();
                pq.pop();
            }
        }
        std::cout << ans << '\n';
    }
    return 0;
}

D. Remove Two Letters

在字符串中去掉任意两个相连的字母，剩下的串相连，求可以得到多少种不同的字符串。

思路：一开始想hash，但是又不太会hash，又感觉hash很容易被卡。可以这样考虑，从头开始，每次向后转移去掉的两个字母，就是加上上一对字母的前一个，去掉后一对字母的后一个，那直接比较这两个字母即可，只要不同，就对答案有贡献。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e6 + 5;
int t, n;
std::string s;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> s;
        int ans = 0;
        for(int i = 1; i < n - 1; i ++) {
            if(s[i - 1] != s[i + 1]) {
                ans ++;
            }
        }
        std::cout << ans + 1 << '\n';
    }
    return 0;
}

E. Unforgivable Curse

给出两个字符串s和t，目标是把s修改为t，每次修改可以交换相距k或k+1位置的字母，问是否能修改成功。

思路：很显然，如果某个字符需要修改，但是它距离左右边界的距离都小于k，那必然没法修改。对于其他的位置，我们一定可以找到两个位置互换的方法，即可以通过中间字符修改，而顺着修改的顺序逆着回去，可以复原原来在正确位置的字母。easy版本与hard版本相同。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e6 + 5;
int T, n, k;
std::string s, t;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> T;
    while(T --) {
        std::cin >> n >> k;
        std::cin >> s >> t;
        std::map<char, int> mp, mpp;
        for(int i = 0; i < n; i ++) {
            mp[s[i]] ++;
            mpp[t[i]] ++;
        }
        bool flag = true;
        for(auto [x, y] : mp) {
            if(y != mpp[x]) {
                flag = false;
                break;
            }
        }
        if(!flag) {
            std::cout << "NO" << '\n';
            continue;
        }
        for(int i = 0; i < n; i ++) {
            if(s[i] != t[i] && std::max(i, n - i - 1) < k) {
                flag = false;
                break;
            }
        }
        std::cout << (flag ? "YES" : "NO") << '\n';
    }
    return 0;
}

F. Dasha and Nightmares

给出n个字符串，问有多少对不同的字符串，使得两个字符串连接起来满足以下条件：字符串中包含25个不同的字母；每个字母的个数为奇数个；字符串长度为奇数。

思路：思路来自cup_pyy佬。考虑哈希。但是显然STL自带的哈希表很容易会被卡掉，就需要一些高端方法自定义哈希表，因为是奇数，所以可以采用位运算实现代码。用二进制下的26位数字存所有的目标字符串，开26个哈希表存对于每个字母不存在时满足条件的方案数。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
#define int long long
const int N = 2e5 + 5;
int n;
int num[30], cnt[30];
std::string s;

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = std::chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> n;
    for(int i = 0; i < 26; i ++) {
        num[i] = ((1 << 26) - 1) ^ (1 << i);
    }
    std::unordered_map<int, int, custom_hash> mp[26];
    for(int i = 0; i < 26; i ++)
        mp[i].reserve(n);
    int ans = 0;
    for(int i = 0; i < n; i ++) {
        std::cin >> s;
        int mask = 0;
        memset(cnt, 0, sizeof(cnt));
        for(auto u : s)
            cnt[u - 'a'] ++;
        for(int i = 0; i < 26; i ++) {
            if(cnt[i] & 1)
                mask ^= (1 << i);
        }
        for(int i = 0; i < 26; i ++) {
            if(!cnt[i] && mp[i].count(mask ^ num[i]))
                ans += mp[i][mask ^ num[i]];
        }
        for(int i = 0; i < 26; i ++) {
            if(!cnt[i])
                mp[i][mask] ++;
        }
    }
    std::cout << ans << '\n';
    return 0;
}