Educational Codeforces Round 142 (Rated for Div. 2) A-D

比赛链接

A

题意

给定 $n$ 个怪物的血量 $h_i$ ，每次可以选择两种操作之一：

1. 选择一个怪物直接杀死。
2. 选择两个怪物血量减一（怪物血量为 $0$ 视作死亡）。

问最少多少次操作可以消灭所有怪物。

题解

知识点：贪心。

存在一对血量为 $1$ 的怪物选择操作2最好，否则选择操作1。

时间复杂度 $O(n)$

空间复杂度 $O(1)$

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
bool solve() {
    int n;
    cin >> n;
    int cnt = 0;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        if (x == 1) cnt++;
    }
    int rst = n - cnt / 2 * 2;
    cout << rst + cnt / 2 << '\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

题意

两个观众A和B的初始心情都为 $0$ 。

给定四个数 $a,b,c,d$ 表示四种笑话的个数，$a$ 能使得心情都加 $1$ ，$b$ 能使A心情加 $1$ B心情减 $1$ ，$c$ 能使B心情加 $1$ A心情减 $1$ ，$d$ 能使心情都减 $1$ 。任意一个观众的心情变为负数，则停止。

问最多能讲几个笑话。

题解

知识点：贪心。

分两类情况：

1. $a = 0$ ，最多只能操作一次。
2. $a \neq 0$ ，可以操作 $a + 2\cdot \min(b, c) + \min(a, |b - c| + d) + [|b - c| + d > a]$ 次。

时间复杂度 $O(1)$

空间复杂度 $O(1)$

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
bool solve() {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    if (a == 0) {
        cout << min(b + c + d, 1) << '\n';
        return 1;
    }
    else {
        int ans = a + 2 * min(b, c) + min(a, abs(b - c) + d) + (abs(b - c) + d > a);
        cout << ans << '\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

题意

给一个长为 $n$ 的排列，每次操作可以任选两个数，其中小的挪到开头，大的挪到末尾，问最少几次操作可以使得排列有序。

题解

知识点：贪心，枚举，双指针。

注意到，操作不影响没有被操作过的数字的相对位置，因此考虑排列中不需要操作的数字。显然，最终被保留的数字应该是连续上升的一个子序列，如 23456 是，而 13456 不是因为 $1$ 和 $3$ 中间没有 $2$ 。

假设我们操作了某一组数 $(x,y)$ ，那么 $(x,y),(x-1,y+1),\cdots ,(1,n)$ 一定都需要操作一遍才能保证这些数字有序。因此只有中间的数我们不需要操作，所以我们保留的数字应该从中间开始往外拓展。

若 $n$ 为奇数，则从中点 $\dfrac{1+n}{2}$ 开始往两边扩展；若 $n$ 为偶数，先保证 $\left\lfloor \dfrac{1+n}{2} \right\rfloor ,\left\lceil \dfrac{1+n}{2} \right\rceil$ 有序，再从这两个数两边扩展，如果不有序直接输出 $\dfrac{n}{2}$ 。

为了方便找到某个数的位置，我们可以先处理数到位置的映射 $pos$ ，再利用双指针 $l,r$ 指向扩展的边界，向两边同时扩展，如果有一边扩展不了那就不需要继续了，最后结果是 $l-1$ 。

时间复杂度 $O(n)$

空间复杂度 $O(n)$

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
int pos[200007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        pos[x] = i;
    }
    int l = (1 + n) / 2, r = (1 + n + 1) / 2;
    if (pos[l] > pos[r]) {
        cout << n / 2 << '\n';
        return 1;
    }
    while (1 < l && r < n) {
        if (pos[l - 1] > pos[l] || pos[r] > pos[r + 1]) break;
        l--;
        r++;
    }
    cout << l - 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

题意

给你 $n$ 个长为 $m$ 的排列 $a_i$ 。

定义一个排列 $p$ 的值为满足 $p_i = i,i \in[1,k]$ 中 $k$ 的最大值。

定义两个排列 $p,q$ 的乘法 $p \cdot q$ 为 $r_i = q_{p_i}$ 。

对于给定的 $n$ 个排列中，对于每个排列 $a_i$ 找到另一个排列 $a_j$ （ $j$ 可以等于 $i$ ）使得 $a_i \cdot a_j$ 的值最大，求出这 $n$ 个最大值。

题解

知识点：枚举。

先考虑两个排列 $p,q$ 乘积的求值过程，即如何求出 $q_{p_1} = 1,\cdots,q_{p_k} = k$ 中 $k$ 最大值。

显然 $q_{p_1} = 1$ ，即 $q$ 中 $1$ 的位置是 $p_1$ ，我们就能得到 $k$ 至少是 $1$ ，以此类推直到 $q_{p_i} \neq i$ 就能得到 $k = i-1$ ，复杂度是 $O(n^2m^2)$ ，先考虑先优化枚举过程。

既然我们要知道某个数的位置，那么我们可以先预处理出 $q$ 所有数字出现的位置 $pos$ 。我们发现 $q_{p_i} = i$ 等价于 $pos_i = p_i$ ，即 $i$ 出现的位置等于 $p_i$ 那么自然可以得到 $q_{p_i} = i$ ，由此我们从 $pos_1 = p_1$ 开始找到最大的 $k$ 满足 $pos_k = p_k$ 即可。现在复杂度是 $O(n^2m)$ ，考虑优化 $n$ 次查找。

我们发现查找的过程，其实就是一个 $p$ 和 $n$ 个 $pos$ 匹配最长前缀的过程，可以用字典树 trie 解决，复杂度是 $O(nm)$ 。但这里 $m$ 不大（其实是我不会字典树），我们可以将排列用十进制压缩成一个整数，用 map 记录 $n$ 个排列的前缀信息来解决。设 $mp_i$ 为 $n$ 个排列的 $pos$ 前 $i$ 个数的前缀信息，例如排列 $pos = [3,1,4,2]$ 前三个数字的信息就是 $314$ ，记录在 $mp_3$ 中。例如，我们查找 $p = [4,3,2,1]$ 前 $2$ 个数的匹配信息时，只要判断 $mp_2$ 中有无 $43$ 即可。到此为止，我们对 $p$ 从前 $1$ 个数依次查找，最多查找 $m$ 次就可以找到最大的 $k$ 了，复杂度是 $O(nm\log n)$ 。

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

空间复杂度 $O(nm)$

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
int a[50007][11];
int pos[11];
map<ll, int> mp[11];
bool solve() {
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= m;i++) mp[i].clear();
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) {
            cin >> a[i][j];
            pos[a[i][j]] = j;
        }
        ll _t = 0;
        for (int j = 1;j <= m;j++) {
            _t = _t * 10 + pos[j] - 1;
            mp[j][_t] = 1;
        }
    }
    for (int i = 1;i <= n;i++) {
        ll _t = 0;
        int ans = m;
        for (int j = 1;j <= m;j++) {
            _t = _t * 10 + a[i][j] - 1;
            if (!mp[j][_t]) {
                ans = j - 1;
                break;
            }
        }
        cout << ans << ' ';
    }
    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;
}