Codeforces 938 解题 Div 3

太久没做题了, 先拿个Div 3开刷。

Codeforces Round 938 Div 3:

A: 

首先我们可以发现到若2 * a <= b, 那么我们n >= 2 的时候，拿b是最优的。

若我们现在拿了许多的2以后， 我们还有余数 = 1, 我们就用a补上。

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

void solve() {
    int n, a, b; cin >> n >> a >> b;
    if (2 * a <= b) cout << n * a << '\n';
    else cout << (n / 2) * b + (n & 1) * a << '\n';
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

B:

B 非常简单就是求你的数和他的数是不是完全重合的。

我当时是直接用multiset来搞，没找到就是不一样，找到的话就移除掉一个数。

其实也可以直接推进一个vector 然后sort再一个一个对比。

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

void solve() {
    multiset<int> S;
    int n, c, d; cin >> n >> c >> d;
    int mn = 1E9 + 9;
    for (int i = 1; i <= n * n; i++) {
        int x; cin >> x;
        S.insert(x);
        mn = min(mn, x);
    }
    bool ok = true;
    for (int i = 1; i <= n; i++) {
        int o = mn + (i - 1) * d;
        for (int j = 1; j <= n; j++) {
            int p = o + (j - 1) * c;
            if (S.find(p) == S.end()) ok = false;
            else S.erase(S.find(p));
        }
    }
    if (ok) cout << "YES\n";
    else cout << "NO\n";
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

C:

C也是一眼的题。我们首先可以发现到前面的数承受了ceil(K / 2) (向上取整)， 后面的数则是承受了 K / 2。

那么我们可以直接暴力这个承受伤害的过程。

我为了写代码方便我特判了一下当 K >= sum(A) 的情况。

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

void solve() {
    int n; i64 k; cin >> n >> k;
    vector<i64> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    if (k >= accumulate(a.begin(), a.end(), 0LL)) {
        cout << n << '\n';
        return;
    }
    int p = 0; i64 rem = (k + 1) / 2;
    while (rem) {
        i64 use = min(rem, a[p]);
        a[p] -= use;
        rem -= use;
        if (a[p] == 0) p++;
    }
    p = n - 1; rem = k / 2;
    while (rem) {
        i64 use = min(rem, a[p]);
        a[p] -= use;
        rem -= use;
        if (a[p] == 0) p--;
    }
    int ans = 0;
    for (int i = 0; i < n; i++) if (a[i] != 0) ans++;
    cout << n - ans << '\n';
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

D:

啊这题一看就感觉会了。

首先我们数字i的贡献其实就是min(ocA[i], ocB[i])。

ocA[i]表示i出现在A的次数, B相同。

那我们想要移除掉就减上以前的贡献，做出我们想要的改变， 再加上新的贡献。

那我们就可以算多少个i满足条件。

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

void solve() {
    int n, m, k; cin >> n >> m >> k;
    vector<int> a(n + 1), b(m + 1);
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= m; i++) cin >> b[i];
    map<int,int> ocA, ocB;
    for (int i = 1; i <= m; i++) ocB[b[i]]++;
    int cur = 0;
    function<void(int,int)> work = [&] (int x, int op) {
        cur -= min(ocA[x], ocB[x]);
        ocA[x] += op;
        cur += min(ocA[x], ocB[x]);
    };
    int ans = 0;
    for (int i = n; i >= 1; i--) {
        if (i + m <= n) work(a[i + m], -1);
        work(a[i], +1);
        if (i <= n - m + 1 && cur >= k) ans++;
    }
    cout << ans << '\n';
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

E:

首先看到我们可以做到O(N ^ 2)。

那么我们枚举从大到小，若当前的数满足条件，我们这不需要再继续往下搜了。

那么我们考虑怎么判断一个数行不行。让当前的x表示枚举的数。

我们从后面开始判断。若s[i]当前 = 0, 我们则需要反转他 （和前面的)。那么我们其实需要维护一个suffix sum来判断当前是否做了反转。

若我们的s[i] = 0, 且i < x, 那我们就可以说这一个数x不满足条件了。

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

void solve() {
    int n; cin >> n;
    string s; cin >> s;
    s = ' ' + s;
    function<bool(int)> work = [&] (int x) {
        vector<int> suf(n + 1);
        for (int i = n; i >= 1; i--) {
            int o = s[i] - '0';
            if (i + 1 <= n) suf[i] += suf[i + 1];
            o += suf[i];
            o %= 2;
            if (o == 0) {
                suf[i]++;
                if (i - x >= 0) suf[i - x]--;
                else return false;
            }
        }
        return true;
    };
    if (count(s.begin(), s.end(), '1') == n) {
        cout << n << '\n';
        return;
    }
    for (int i = n; i >= 1; i--) {
        if (work(i)) {
            cout << i << '\n';
            return;
        }
    }
    cout << 0 << '\n';
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

F: 

这题不错虽然感觉没那么难。

首先我们可以看到当一个数的数量是偶数，他是没有贡献的。

那么我们可以打一个表来看什么时候我们xor = 0。

我们发现到我们要么是1， 2， 3， 4： 偶，偶，偶，偶， 要么是1， 2， 3， 4：奇，奇，奇，偶。

发现到其实若我们想要花费更加多的数来满足奇，奇，奇，偶的条件。

所以我们贪心取偶，偶，偶，偶。那么贡献就是 a/2 + b/2 + c/2 + d/2这样。

但是我们有可能最后有1, 1, 1, 0或者1, 1, 1, 1的数。那么我们在这个情况下取奇，奇，奇，偶，答案+1

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

void solve() {
    int a, b, c, d; 
    cin >> a >> b >> c >> d;
    int ans = (a / 2) + (b / 2) + (c / 2) + (d / 2);
    a %= 2; b %= 2; c %= 2; d %= 2;
    if (a == 1 && b == 1 && c == 1) ans++;
    cout << ans << '\n';
    // all even or 1, 2, 3 is odd
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

G: 

G有点傻了，不知道为什么vector开在function里面会爆。渍渍渍。

考虑枚举每一个数x是否可以到达(n, m)。首先我们让p[i][j] = a[i][j] % x 是不是 0。

然后呢，我们就可以非常简单的判断(i, j)是否可以被到达。这个应该不难。

现在发现到我们其实不需要枚举那么多数，我们枚举每个a[1][1]的因子就行。

我们直接sieve 然后暴力就可以。技术含量不高。

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

int gcd(int x, int y) {
    if (y == 0) return x;
    return gcd(y, x % y);
}
vector<int> _div[1000003];
void solve() {
    int n, m; cin >> n >> m;
    vector<vector<int>> a(n + 1, vector<int>(m + 1));
    auto ok = a;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> a[i][j];
        }
    }
    auto work = [&](int x) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                ok[i][j] = 0;
            }
        }
        ok[1][1] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (a[i][j] % x) {
                    ok[i][j] = 0;
                    continue;
                }
                if (i - 1 >= 1) ok[i][j] |= ok[i - 1][j];
                if (j - 1 >= 1) ok[i][j] |= ok[i][j - 1];
            }
        }
        return ok[n][m];
    };
    int ans = 1;
    for (auto v : _div[a[1][1]]) if (work(v)) ans = max(ans, v); 
    cout << ans << '\n';
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    for (int i = 1; i <= 1E6; i++) {
        for (int j = i; j <= 1E6; j += i) {
            _div[j].push_back(i);
        }
    }

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

H: 

一眼就知道R不能取值太高，直接暴力算R的上限 = 12。

那么我们就可以快乐的暴力算差值了。

我们枚举每个有塔的地方，让use[r] = 多了多少伤害 - 3 ^ r。

那么根据题目我们不能够拿同一个R，我们就可以维持一个dp[S] = 最高差值和，S在2进制表示第i个r有没有被使用了。

这就是什么bit DP。

答案就是dp里的最大值。

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

void solve() {
    int n, m, k; cin >> n >> m >> k;
    // max R = 12
    vector<vector<char>> grid(n + 1, vector<char>(m + 1));
    vector<vector<int>> P(n + 1, vector<int>(m + 1));
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> grid[i][j];
        }
    }
    for (int i = 1; i <= k; i++) {
        int x, y, p; 
        cin >> x >> y >> p;
        P[x][y] += p;
    }
    vector<i64> dp((1 << 13) + 50, -1E18);
    dp[0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (P[i][j] == 0) continue;
            vector<i64> dif(13);
            i64 pw = 1;
            for (int r = 1; r <= 12; r++) {
                pw *= 3;
                i64 dmg = 0;
                for (int x = 1; x <= n; x++) {
                    for (int y = 1; y <= m; y++) {
                        if (grid[x][y] == '#' && (i - x) * (i - x) + (j - y) * (j - y) <= r * r) {
                            dmg += P[i][j];
                        }
                    }
                }
                dif[r] = dmg - pw;
            }
            for (int bit = (1 << 13); bit >= 0; bit--) {
                for (int x = 0; x < 13; x++) {
                    if (bit >> x & 1) {
                        dp[bit] = max(dp[bit], dp[bit ^ (1 << x)] + dif[x]);
                    }
                }
            }
        }
    }
    // for (int i = 0; i < (1 << 13); i++) cout << dp[i] << ' ';
    //     cout << '\n';
    cout << *max_element(dp.begin(), dp.end()) << '\n';
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

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

 

嗯，不错的题目。