Codeforces Round 961 (Div. 2) 补题记录（A~D）

合集 - CodeForces 比赛合集(19)

1.CodeForces Round #939(Div. 2) 补题记录（A~F）2024-04-16 2.CodeTON Round 8 (Div. 1 + Div. 2, Rated, Prizes!) 补题记录（A~A）2024-04-17 3.Educational Codeforces Round 163 (Rated for Div. 2) 补题记录（A~D）2024-04-17 4.CodeForces Round #951(Div. 2) 补题记录（A~E）2024-06-07 5.Codeforces Global Round 26 补题记录（A~C2）2024-06-10 6.CodeForces Round #959 sponsored by NEAR (Div. 1 + Div. 2) 补题记录（A~E）2024-07-20 7.Codeforces Round 960 (Div. 2) 补题记录（A~D）2024-07-21

8.Codeforces Round 961 (Div. 2) 补题记录（A~D）2024-07-24

上大分，赢！

A

考虑将每一条对角线上可以存放的砝码数量都记录一下，从大到小排序，然后直接暴力贪心选择。

此时可以发现数量一定形如 $n, n - 1, n - 1, n - 2, n - 2, n - 3, n - 3, \dots, 1, 1$ 这样的形式。直接暴力减即可。

时间复杂度为 $O (n)$ 。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 500100;
int a[N];
signed main() {
    int T;
    scanf("%lld", &T);
    while (T--) {
        int n, k;
        scanf("%lld%lld", &n, &k);
        vector<int> v;
        v.emplace_back(n);
        for (int i = n - 1; i; --i) v.emplace_back(i), v.emplace_back(i);
        int cnt = 0;
        int i = 0;
        while (k > 0) {
            k -= v[i];
            ++cnt;
            ++i;
        }
        printf("%lld\n", cnt);
    }
}

B2

B1 做法同 B2。

考虑枚举每一个值 $i$ ，计算出其可以选择的最大数目。然后再枚举每一个值 $i + 1$ ，计算其在选择尽量多 $i$ 的前提下最大的数目。

然后计算出这个最大的开销，令 $i$ 值选择了 $v_{1}$ 个， $i + 1$ 值还有 $v_{2}$ 个没有选择。则可以最多带来 $min (v_{1}, v_{2})$ 的收益。所以答案就是 $min (m, i v_{1} + (i + 1) v_{2} + min (v_{1}, v_{2}))$ 。

开一个 map 计算出 $v_{1}$ 和 $v_{2}$ 的最大值即可。时间复杂度为 $O (n \log n)$ 。

还是这张图：

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 500100;
int a[N], b[N];
signed main() {
    int T;
    scanf("%lld", &T);
    while (T--) {
        int n, m;
        scanf("%lld%lld", &n, &m);
        for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
        for (int i = 1; i <= n; ++i) scanf("%lld", &b[i]);
        map<int, int> mp;
        for (int i = 1; i <= n; ++i) mp[a[i]] += b[i];
        sort(a + 1, a + n + 1);
        int mx = 0;
        for (int i = 1; i <= n; ++i) {
            int key = 0;
            int val = a[i];
            int remain = mp[a[i]];
            remain = min(remain, m / val);
            int aix = remain;
            key = a[i] * remain;
            remain = mp[a[i] + 1];
            remain = min(remain, (m - key) / (a[i] + 1));
            key += (a[i] + 1) * remain;
            remain = min(aix, mp[a[i] + 1] - remain);
            key += remain;
            if (key > m) key = m;
            mx = max(mx, key);
        }
        printf("%lld\n", mx);
    }
}

C

首先考虑一下弱化版 CF1883E 的做法。

每一次将一个数乘以 $2$ ，很快就会爆 long long 甚至 __uint128。因此考虑一些优美的性质：

$\log_{2} 2 a_{i} = 1 + \log_{2} a_{i}$ 。

也就是说，可以考虑对于每一个 $a_{i}$ ，都对其取一次 $\log_{2}$ 操作。这样一来，问题转化为：

给定一个序列 $a$ ，每一次可以将某一个元素 $+ 1$ ，问多少次操作之后序列单调不递减。

这个问题就可以直接贪心的模拟了。

然后考虑本题。本题要求的是对一个数平方。也考虑同样的转化方式：

$\log_{2} (a_{i}^{2}) = 2 \log_{2} a_{i}$ 。
$\log_{2} (2 \log_{2} a_{i}) = \log_{2} a_{i} + \log_{2} 2 = \log_{2} a_{i} + 1$ 。

也就是说， $\log_{2} (\log_{2} (a_{i}^{2})) = \log_{2} a_{i} + 1$ 。对于每一个元素 $a_{i}$ 做两遍 $\log_{2}$ 就得到的上面简化后的问题。

时间复杂度为 $O (n)$ ，注意要使用 long double 否则会被卡精度。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 500100;
int a[N];
long double b[N];
signed main() {
    int T;
    scanf("%lld", &T);
    while (T--) {
        int n;
        scanf("%lld", &n);
        for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
        bool ok = 1;
        for (int i = 2; i <= n; ++i) if (a[i] < a[i - 1]) ok = 0;
        if (ok) printf("0\n");
        else {
            int pre = 0;
            ok = 1;
            for (int i = 1; i <= n; ++i) {
                pre = max(pre, a[i]);
                if (a[i] == 1) {
                    if (pre > 1) {
                        ok = 0;
                        break;
                    }
                }
            }
            if (!ok) puts("-1");
            else {
                for (int i = 1; i <= n; ++i)
                    b[i] = log2l(log2l(a[i]));
                int cnt = 0;
                for (int i = 2; i <= n; ++i) {
                    if (b[i] < b[i - 1]) {
                        double qwq = b[i - 1] - b[i];
                        int kif = (int)ceill(qwq);
                        cnt += kif;
                        b[i] += kif;
                    }
                }
                printf("%lld\n", cnt);
            }
        }
    }
}

D

考虑 dp。

设 $f_{i}$ 表示不存在以集合 $i$ 结尾的字符，是否是合法的。

那么显然有下列的初始条件：

$f_{p} = 0$ ，若 $p$ 为子状态数为 $1$ ，且唯一一个子状态为字符串结尾字符。
$f_{p} = 0$ ，若 $p$ 状态包含其中一个长度为 $k$ 的子区间中所有的元素。
$f_{p} = 1$ ，若 $p$ 状态同时不满足下列的条件。

但是这显然是错的。因此考虑 dp 更新答案。

按照顺序枚举集合 $i \in [1, 2^{c})$ 。则有对于任意的一个 $j$ 满足 $j$ 是集合 $i$ 中的一个子元素， $f_{j} = f_{j} AND f_{j \oplus 2^{i}}$ 。

最终就是在所有满足 $f_{i} = 0$ 的元素中，找到状态中含有 $0$ 数量最多的那一个状态就是答案。

时间复杂度为 $O (c 2^{c} + n c)$ 。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 500100;
int a[N], box[N], f[N];
signed main() {
    int T;
    scanf("%lld", &T);
    while (T--) {
        int n, c, k;
        scanf("%lld%lld%lld", &n, &c, &k);
        string s; cin >> s;
        for (int i = 0; i < c; ++i) box[i] = 0;
        for (int i = 0; i < k; ++i) ++box[s[i] - 'A'];
        for (int i = 0; i < (1ll << c); ++i) f[i] = 1;
        f[(1ll << (s[n - 1]) - 'A')] = 0;
        for (int l = 0, r = k - 1; r < n; ++l, ++r) {
            int mask = 0;
            for (int j = 0; j < c; ++j)
                if (box[j]) mask |= (1ll << j);
            f[mask] = 0;
            if (r < n - 1)
                --box[s[l] - 'A'], ++box[s[r + 1] - 'A'];
        }
        for (int i = 1; i < (1ll << c); ++i)
            for (int j = 0; j < c; ++j)
                if (i >> j & 1) f[i] &= f[i ^ (1ll << j)];
        int mi = c;
        for (int i = 1; i < (1ll << c); ++i)
            if (f[i]) mi = min(mi, c - (int)__builtin_popcountll(i));
        printf("%lld\n", mi);
    }
}