Educational Codeforces Round 141 (Rated for Div. 2) A-E

比赛链接

A

题意

给一个数组 \(a\) ，要求重排列以后 \(a[i] \neq a[1,i-1]\) ，其中 \(a[1,i-1]\) 是前 \(i-1\) 项和。

如果无解则输出 NO ；否则，给出一个合法的重排列后的 \(a\) 。

题解

知识点：贪心。

显然先从大到小排序。

若 \(a_1 = a_2\) ，则需要用其他一个数字替换 \(a_1\) ，若此时 \(a[1] = a[n]\) 则没有数字换无解；否则可以交换 \(a_1,a_n\) 。

否则，直接输出即可。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[57];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    sort(a + 1, a + n + 1, [&](int a, int b) {return a > b;});
    if (a[1] == a[2]) {
        if (a[1] == a[n]) return false;
        swap(a[1], a[n]);
    }
    cout << "YES" << '\n';
    for (int i = 1;i <= n;i++) cout << a[i] << " \n"[i == 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;
}

B

题意

构造一个 \(n \times n\) 的矩阵，其中元素为整数 \([1,n^2]\) ，每个数字必须使用且只使用一次。

问，所有相邻元素的差的绝对值最多能有多少种，输出最多的那个矩阵。

题解

知识点：构造。

注意到值的范围是 \([1,n^2-1]\) ，猜测可以取满。

我们可以构造类似：

\[\begin{pmatrix}
1 & 25 & 2 & 24 & 3\\
21 & 5 & 22 & 4 & 23\\
6 & 20 & 7 & 19 & 8\\
16 & 10 & 17 & 9 & 18\\
11 & 15 & 12 & 14 & 13\\
\end{pmatrix}
\]

从第一行左边开始，走之字形，从 \(1,n^2\) 交替递增递减进行。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[57][57];
bool solve() {
    int n;
    cin >> n;
    int l = 1, r = n * n, f = 0;
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= n;j++) {
            a[i][j] = f ? r-- : l++;
            f ^= 1;
        }
        if (!(i & 1)) reverse(a[i] + 1, a[i] + n + 1);
    }
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= n;j++) cout << a[i][j] << ' ';
        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;
}

C

题意

有编号 \(1\) 到 \(n\) 的选手，任意两个选手之间会进行且只进行一次比赛，编号大的赢。

你同样也是参赛选手，但你与 \(i\) 号选手比赛的获胜条件是你需要花费 \(a_i\) 的时间否则就会输掉，你共有 \(m\) 的时间可花费。

最终根据获胜场次排名，场次相同的排名相同，排名顺位。例如其他选手获胜场次为 \(3,3,3,2,1\) ，若你获胜 \(3\) 场那你和前三个选手并列第一，若你获胜 \(2\) 场那你和第四个选手并列第 \(4\) 。

问，你最多能排第几。

题解

知识点：贪心，二分。

首先，每个选手都已经有固定胜利场次了，\(i\) 号选手赢 \(i-1\) 场排名 \(n-i+1\) 。

假设你赢了 \(k\) 场，因为 \(\geq k+2\) 号选手，你无论输赢他们都赢的场次一定大于你的；\(\leq k\) 号选手，你无论输赢他们赢的场次一定小于等于你的。因此，你的排名只可能被 \(k+1\) 号选手影响。

若 \(k\) 场中赢了 \(k+1\) 号选手，那么你的排名是第 \(n-k\) 名；否则，\(k+1\) 号选手会比你多赢一场，你的排名是第 \(n-k+1\) 名。

假设最多能赢 \(k\) 场，那么你的排名 \(\geq n-k+1\) ；若赢了 \(<k\) 场，则排名一定 \(\leq n-k+1\) 。因此，我们优先希望赢的最多，再考虑能不能赢 \(k+1\) 号选手。

我们先贪心的求出 \(a_i\) 从小到大排序后的前缀和 \(sum_i\) ，用二分查找最后一个 \(sum_i \leq m\) 则此时 \(i = k\) 。随后，我们判断 \(sum_k\) 中是否已经包括了 \(a_{k+1}\) 。我们可以分类讨论：

1. 满足 \(sum_{k-1} + a_{k+1} \leq m\) ，若没有包括 \(a_{k+1}\)，那就可以将第 \(k\) 大的 \(a_i\) 换成 \(a_{k+1}\) 使其包括；若已经包括 \(a_{k+1}\) ，这个不等式自然成立。因此，排 \(n-k\) 名。
2. 否则，\(a_{k+1}\) 一定没有被包括，并且不能被替换进去。因此，排 \(n-k+1\) 名。

特判 \(k = 0,n\) 的情况。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[500007];
int sum[500007];
bool solve() {
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= n;i++) cin >> a[i], sum[i] = a[i];
    sort(sum + 1, sum + n + 1);
    for (int i = 1;i <= n;i++) sum[i] += sum[i - 1];
    int k = upper_bound(sum + 1, sum + n + 1, m) - sum - 1;
    if (k == 0) cout << n + 1 << '\n';
    else if (k == n) cout << 1 << '\n';
    else if (sum[k - 1] + a[k + 1] <= m) cout << n - k << '\n';
    else cout << n - k + 1 << '\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

题意

给一个数组 \(a\) ，执行 \(n-2\) 次操作，第 \(i\) 次操作将 \(a_{i+1}\) 任选一个相邻元素加上 \(a_{i+1}\) ，另一个相邻元素减去 \(a_{i-1}\) 。

问最终能生成多少种数组，不同数组至少有一个元素不同。

题解

知识点：线性dp。

设 \(f[i][j]\) 表示为考虑了前 \(i\) 个数，且下一个操作数为 \(j\) 的方案数。

初始条件是 \(f[2][a[2]] = 1\) ，因为第一个数不操作，从 \(i = 2\) 开始。转移方程为：

\[\begin{aligned}
f[i+1][a[i+1]+j] = f[i+1][a[i+1]+j] + f[i][j]\\
f[i+1][a[i+1]-j] = f[i+1][a[i+1]-j] + f[i][j]\\
\end{aligned}
\]

注意到 \(j = 0\) 时，两个方程是同一个，只能执行一次。

可以滚动数组优化空间。

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

空间复杂度 \(O(n + \sum a_i)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

const int mod = 998244353;
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    vector<int> a(n + 1);
    int sum = 0;
    for (int i = 1;i <= n;i++) cin >> a[i], sum += a[i];
    vector<int> f(2 * sum + 1);
    f[a[2] + sum] = 1;
    for (int i = 2;i <= n - 1;i++) {
        vector<int> g(2 * sum + 1);
        for (int j = 0;j <= 2 * sum;j++) {
            if (!f[j]) continue;
            if (j == sum) g[sum + a[i + 1]] = (g[sum + a[i + 1]] + f[j]) % mod;
            else {
                g[sum + a[i + 1] + (j - sum)] = (g[sum + a[i + 1] + (j - sum)] + f[j]) % mod;
                g[sum + a[i + 1] - (j - sum)] = (g[sum + a[i + 1] - (j - sum)] + f[j]) % mod;
            }
        }
        f = g;
    }
    int ans = 0;
    for (int i = 0;i <= 2 * sum;i++) ans = (ans + f[i]) % mod;
    cout << ans << '\n';
    return 0;
}

E

题意

有 \(n\) 个boss，对于第 \(i\) 个boss，A击杀需要 \(a_i\) 次尝试，B击杀需要 \(b_i\) 次尝试。

A和B轮流尝试，每次进行 \(k\) 次尝试，A先尝试，各自的尝试是独立的。

如果某轮尝试总数大于等于自己需要的尝试次数，则这个boss算作自己击杀的。

每次boss被某人击杀后，则A和B同时开始尝试下一个boss，尝试计数清零。

问， \(k \in [1,n]\) 取哪些能保证每个boss都是A击杀的。

题解

知识点：数论，差分。

为了使得每次都是A先击杀boss，我们要保证A击杀boss的轮数要小于等于B，即 \(k\) 要满足 \(\lceil \frac{a_i}{k} \rceil \leq \lceil \frac{b_i}{k} \rceil\) 。

显然 \(a_i\leq b_i\) 时，所有 \(k\) 都成立。

当 \(a_i > b_i\) 时，我们可以枚举 \(k\) 的倍数，若某个倍数 \(k'\) 满足存在 \(i\) 使得 \(b_i \leq k' < a_i\) 则 \(\lceil \frac{a_i}{k} \rceil > \lceil \frac{b_i}{k} \rceil\) 不合法；否则 \(\lceil \frac{a_i}{k} \rceil = \lceil \frac{b_i}{k} \rceil\) 合法。对此，我们可以用一个数组 \(d\) 记录所有被 \([b_i,a_i)\) 的覆盖区间，这个可以用差分做到。

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

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

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[200007], b[200007];
int d[200007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i], d[i] = 0;
    for (int i = 1;i <= n;i++) cin >> b[i];
    for (int i = 1;i <= n;i++) {
        if (a[i] > b[i]) {
            d[b[i]]++;
            d[a[i]]--;
        }
    }
    for (int i = 1;i <= n;i++) d[i] += d[i - 1];
    vector<int> ans;
    for (int i = 1;i <= n;i++) {
        bool ok = 1;
        for (int j = i;j <= n;j += i) {
            if (d[j]) {
                ok = 0;
                break;
            }
        }
        if (ok) ans.push_back(i);
    }
    cout << ans.size() << '\n';
    for (int i = 0;i < ans.size();i++) cout << ans[i] << " \n"[i == ans.size() - 1];
    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;
}