【补题】Codeforces Round #779 (Div. 2) A ~ D1

原创已于 2022-03-28 22:52:51 修改 · 340 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2022-03-28 11:00:00 首次发布

codeforces 专栏收录该内容

6 篇文章

订阅专栏

本文解析了Codeforces Round #779 (Div.2) A-D1题目的解题思路及代码实现，涵盖模拟算法、组合数学、序列分析及位运算等核心算法知识点。

Codeforces Round #779 (Div. 2) A ~ D1

掉分……

A

思路

纯模拟，两个0相隔位置小于2的考虑，其他的不考虑。

代码（C++）

#include <bits/stdc++.h>
using namespace std;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    cin >> t;
    while (t --) {
        int n;
        string s;
        cin >> n >> s;

        vector<int>v;
        for (int i = 0; i < s; ++ i) 
            if (s[i] == '0')
                v.push_back(i);

        int ans = 0; 
        for (int i = 1; i < v.size(); ++ i)
            if (v[i] == v[i - 1] + 1)
                ans += 2;
            else if (v[i] == v[i - 1] + 2) 
                ans += 1;

        cout << ans << '\n';
    }

    return 0;
}

B

思路

如果一开始先打个表看看序列就不至于被卡到了。

通过打表会发现，奇数位置上的数字是偶数，偶数位置上的数字是奇数。而且，如果元素个数为奇数的话，那么是不存在符合题意的。所以只需要考虑偶数排列组合可能性与奇数排列组合可能性，然后两个再相乘就可以了。

还有一个事情：板子准备多一点。

代码（C++）

#include <bits/stdc++.h>
using namespace std;

#define vec std::vector
using ll = long long;
using ill = __int128_t;

constexpr ll MOD = 998244353;

vec<vec<ill>>C;

inline ll mul(ll a, ll b, ll p) {
    a = (a % p + p) % p;
    b = (b % p + p) % p;
    ll d = static_cast<long double>(a) * b / p;
    d = a * b - d * p;
    if (d >= p)
        d -= p;
    if (d < p)
        d += p;
    return d;
}

void solve() [
    int n;
    cin >> n;

    if (n % 2) {
        cout << "0\n";
    } else {
        n /= 2;
        ll ans = 0;
        for (int i = n; i > 1; -- i) {
            ans = mul(ans, C[i][1], MOD);
        }
        ans = mul(ans, ans, MOD);
        cout << ans << '\n';
    }
]

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);

    C.assign(510, vec<ill>());
    for (int i = 0; i < C.size(); ++ i) {
        C[i].assign(i + 1, 0);
        C[i][0] = C[i][i] = 1;
        for (int j = 1; j < i; ++ j) {
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % MOD;
        }
    }

    int t;
    cin >> t;
    while (t --)
        solve();
 
    return 0;
}

C

思路

可以发现符合条件的序列递增的时候相差不会超过1（或者直接减少），并且根据题目意思，把最大数移动到开始在执行操作得到的序列也只是位移了几个位置。因此，可以通过先把最大值移动到开端，然后判断一下序列中递增的差是否存在超过1的即可。

代码（C++）

#include <bits/stdc++.h>
using namespace std;

auto solve() {
    int n;
    cin >> n;
    vector<int> v, t(n);
    for (auto &x : t)
        cin >> x;
    if (count(t.begin(), t.end(), 1) != 1) {
        cout << "NO\n";
        return;
    }
    
    int p = find(t.begin(), t.end(), 1) - t.begin();
    for (int i = p; i < n; ++ i)
        v.push_back(t[i]);
    for (int i = 0; i < p; ++ i) 
        v.push_back(t[i]);
    for (int i = 1; i < n; ++ i) 
        if (v[i] - v[i - 1] > 1) {
            cout << "NO\n";
            return;
        }
    cout << "YES\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    cin >> t;
    while (t --)
        solve();

    return 0;
}

D1

思路

~~还得是打表~~

将样例中的数字转化为二进制的形式，可以看到第 $i$ 位上的1和0的分布情况。统计一下1和0的个数，会刚好发现一个规律：哪一个位置上谁多就是谁，那么结果刚好就是组合后的数字（~~但是根本不知道为什么是这样的……~~）。

所以，可以直接去算算谁比较多，就可以了。

代码（C++）

#include <bits/stdc++.h>

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;
    while (t --) {
        int l, r;
        std::cin >> l >> r;

        std::vector<int>bit(32, 0);
        for (int i = l; i <= r; ++ i) {
            int x;
            std::cin >> x;
            for (int j = 0; j < 32; ++ j) {
                bit[j] += ((x >> j) & 1) == 1 ? 1 : -1;
            }
        }
        
        int ans = 0;
        for (int j = 0; j < 31; ++ j) {
            if (bit[j] > 0) {
                ans |= (1 << j);
            }
        }

        std::cout << ans << '\n';
    }

    return 0;
}