Codeforces Round #884 (Div. 1 + Div. 2) A-E

比赛链接

A

代码

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

bool solve() {
    int a, b;
    cin >> a >> b;
    cout << a + b << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

B

题意

构造一个长为 \(n\) 的排列，使得 \(MEX\) 为质数的子区间的个数最多。

题解

知识点：构造。

当 \(n \leq 2\) 时，只能是 \(1\) 和 \(1,2\) ，接下来讨论 \(n \geq 3\) 的情况。

显然， \(1\) 一定要在区间内，因此假设 \(1\) 的位置是 \(pos\) ，那么个数最多为 \(pos(n-pos+1) - [n+1 \in prime]\) 。

注意到，只需要将 \(2,3\) 放在两侧，即可到达上限。

为了使得上限最大，令 \(pos = n-pos+1\) ，取 \(pos = \left\lfloor \dfrac{n+1}{2} \right\rfloor\) 即可。

时间复杂度 \(O(n)\)

空间复杂度 \(O(1)\)

代码

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

bool solve() {
    int n;
    cin >> n;
    if (n == 1) {
        cout << "1" << '\n';
        return true;
    }
    if (n == 2) {
        cout << "1 2" << '\n';
        return true;
    }

    int pos = 4;
    for (int i = 1;i <= n;i++) {
        if (i == 1) cout << "2" << ' ';
        else if (i == (n + 1 >> 1)) cout << "1" << ' ';
        else if (i == n) cout << "3" << '\n';
        else cout << pos++ << ' ';
    }
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

C

题意

给定一个长为 \(n\) 的整数数组 \(a\) ，每次可以执行一个操作：选择一个位置 \(i\) ，删除 \(a_i\) ，并合并 \(a_{i-1}\) 和 \(a_{i+1}\) 变为 \(a_{i-1} + a_{i+1}\) 。

需要执行操作，直到数组只剩 \(1\) 个数字，问最后这个数字最大是多少。

题解

知识点：贪心，数学。

注意到，只有同奇偶的位置才有机会合并，不同奇偶的一定合并不到。

同时，存在操作，使得任意同奇偶位置的数字合并在一起，因此答案是取奇数位置的正数之和与偶数位置的正数之和的最大值。特别地，若不存在正数，取所有元素里的最大值即可。

时间复杂度 \(O(n)\)

空间复杂度 \(O(1)\)

代码

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

bool solve() {
    int n;
    cin >> n;
    array<ll, 2> ans{};
    int mx = -1e9;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        mx = max(mx, x);
        ans[i & 1] += max(x, 0);
    }
    ll mxans = max(ans[0], ans[1]);
    cout << (mxans ? mxans : mx) << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

D

题意

一个 \(r \times c\) 的字符矩阵 \(A\) 的行主序字符串是将 \(A\) 的所有行拼接得到的，形如：

\[A_{11}A_{12} \cdots A_{1c} \cdots A_{r1}A_{r2} \cdots A_{rc}
\]

一个字符矩阵，若存在相邻两个字符是一样的，那么这个字符矩阵是坏的。

现在需要构造一个长为 \(n\) 的字符串 \(s\) ，使得所有行主序是这个字符串的字符矩阵不是坏的。

题解

方法一

知识点：构造，数论。

一个朴素的想法是，对于任何 \(n\) 的因子 \(d\) ，字符 \(s_i\) 不能和 \(s_{i-d}\) 相同。

因此，我们先可以求出 \(n\) 的所有因子 \(d\) 。构造一个字符时，枚举所有因子 \(d\) ，记录 \(d\) 个字符之前的字符是什么，然后贪心取最小的一个没出现过的字符即可保证字母种类最少，时间复杂度是 \(O(n \sqrt n)\) 的。

但众所周知因子的上界 \(O(\sqrt n)\) 是个很松的上界，实际上 \(10^9\) 内的数字正因数最多有 \(1344\) 个，过这道题是轻轻松松的。

时间复杂度 \(O(n \sqrt n)\)

空间复杂度 \(O(n)\)

方法二

知识点：构造，数论。

基于方法一的朴素想法，我们发现第一个不是 \(n\) 因子的数 \(c\) 是字母种类的下限。因为小于 \(c\) 的都是 \(n\) 的因子，这导致一个字母之前连续 \(c-1\) 个字母必须互不相同。

我们尝试以 \(c\) 为周期构造字符串，验证下限是否合法。以 \(c\) 为周期构造，那么只存在 \(s_i = s_{i+c}(1 \leq i \leq n-c)\) ，但因为 \(kc(k \geq 1)\) 不是 \(n\) 的因子，因此不存在一个因子 \(d\) 使得 \(s_i = s_{i+d}\) ，所以 \(c\) 是合法的。

根据官方题解，上面说的还可以用图论来解释。

将 \(n\) 个字符看作点，需要满足互不相同的限制是边，那么问题等价于图的最小染色问题（颜色种类最少）。

显然，色数（最小染色的颜色数）一定是大于等于团数（最大团的点数），那么我们可以找到最大团（最大完全子图）包含 \(c\) 个点，因此色数一定大于等于 \(c\) 。

我们令色数为 \(c\) ，上面的证明可以理解为不存在一个因子 \(d\) 使得 \(s_i,s_{i+d}\) 之间存在边，因此 \(c\) 是合法的。

时间复杂度 \(O(n)\)

空间复杂度 \(O(1)\)

代码

方法一

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

void get_factor(int n, vector<int> &factor) {
    for (int i = 1;i * i <= n;i++) {
        if (n % i == 0) {
            factor.push_back(i);
            if (n / i != i) factor.push_back(n / i);
        }
    }
}

bool solve() {
    int n;
    cin >> n;

    vector<int> factor;
    get_factor(n, factor);
    sort(factor.begin(), factor.end());

    string s;
    vector<int> f(n + 1);
    for (int i = 1;i <= n;i++) {
        vector<int> vis(26);
        for (auto val : factor) {
            if (i - val <= 0) break;
            vis[f[i - val]] = 1;
        }
        for (int j = 0;j < 26;j++) {
            if (!vis[j]) {
                s += 'a' + j;
                f[i] = j;
                break;
            }
        }
    }
    cout << s << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

方法二

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

bool solve() {
    int n;
    cin >> n;
    int pos = 1;
    while (n % pos == 0) pos++;
    for (int i = 1;i <= n;i++) cout << (char)('a' + (i - 1) % pos);
    cout << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

E

题意

一个 \(n \times m\) 的矩阵，若满足下列要求，则是好的：

1. 矩阵元素只能是 A,B,C 三个字符的一个。
2. 相邻元素不能一样。
3. 任何 \(2 \times 2\) 的子矩阵必须包含 \(3\) 个不同的字符。

问能否构造一个好的矩阵，同时这个矩阵要满足 \(k\) 个约束，每个约束表达为 \((x_1,y_1),(x_2,y_2)\) ，表示这两个位置的元素要一样，保证给出的这两个位置是对角相邻的。

题解

知识点：构造，数论，并查集。

我们将 A,B,C 换为数字 \(0,1,2\) ，观察好的矩阵中某个 \(2 \times 2\) 子矩阵的性质，例如：

\[\begin{matrix}
0& 1&\\
1& 2&
\end{matrix}
\]

我们发现，任意 \(2 \times 2\) 的子矩阵，一定满足：

\[\begin{align}
a_{i,j} - a_{i+1,j} \equiv a_{i,j+1} - a_{i+1,j+1} \pmod 3
\end{align}
\]

即子矩阵左两个元素的差和右两个元素的差是模 \(3\) 相等的。

同时，我们根据这个式子在相同的两行 \(i,i+1\) 上对 \(j\) 递推，可以得到这两行的每一列两个元素的差都是模 \(3\) 相等的，其值为 \(1\) 或 \(2\) 。假设我们用 \(i\) 代表 \(i,i+1\) 两行，那么结论是对于 \(i < n\) 每一行都只有一个值。

同理，将公式变形，可以在相同的两列上对 \(i\) 递推，也可以得到对于 \(j<m\) 每一列都只有一个值。

接下来讨论行和列的值之间的关系。我们可以观察到，一个子矩阵 \((i,j)\) 中，若相等的元素是左上 \((i,j)\) 和右下 \((i+1,j+1)\) ，那么第 \(i\) 行的值和第 \(j\) 列的值一定不同，否则是相同的。

因此， \(k\) 个约束实际上规定的是，某行和某列的值必须相同或者不同，这就变成一个二分图判定的变体了（普通二分图只有邻接必须不同的要求，没有必须相同要求），可以用染色法解决（表示相同的边染同色，不同的边染异色）。当然，也可以用种类并查集解决，这里用的是这种方法。

时间复杂度 \(O(n+m+k\log (n+m))\)

空间复杂度 \(O(n+m+k)\)

代码

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

struct DSU {
    vector<int> fa;

    DSU(int n = 0) { init(n); }

    void init(int n) {
        fa.assign(n + 1, 0);
        iota(fa.begin(), fa.end(), 0);
    }

    int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }

    bool same(int x, int y) { return find(x) == find(y); }

    void merge(int x, int y) { fa[find(x)] = find(y); }
};

tuple<int, int, int> a[4007];
bool solve() {
    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 1;i <= k;i++) {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        a[i] = { x1,min(y1,y2),y1 < y2 };
    }

    DSU dsu(2 * (n + m));
    for (int i = 1;i <= k;i++) {
        auto [x, y, type] = a[i];
        if (dsu.same(x, y + n + !type * (n + m))) return false;
        dsu.merge(x, y + n + type * (n + m));
        dsu.merge(x + n + m, y + n + !type * (n + m));
    }
    cout << "YES" << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << "NO" << '\n';
    }
    return 0;
}