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

比赛链接

A

题解

知识点：数学。

显然长度大于等于3的数字串的最小数位是完全可以通过这些操作留到最后。

长度等于2的数字串只可能是个位数字。

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

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

代码

#include <bits/stdc++.h>

using namespace std;

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--) {
        string str;
        cin >> str;
        if (str.length() == 2) cout << str.back() << '\n';
        else {
            int ans = ~(1 << 31);
            for (int i = 0;i < str.length();i++) ans = min(ans, str[i] - '0');
            cout << ans << '\n';
        }
    }
    return 0;
}

B

题解

知识点：数学，构造。

容易得到三个式子

\[\begin {aligned} x &= ky + a\\ y &= mz + b\\ z &= nx + c\\ \end {aligned} \]

其中 \(k,m,n \in \mathbb{N^+}\)。

通过代入得到

\[x = \frac{kmc + kb + a}{1 - kmn} \]

由于 \(z \mod x = c\) ，因此有 \(x > c\) ，考虑 \(k = 1,m = 1,n = 0\) 得到 \(x = a+b+c , y = b+c , z = c\) 。

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

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

代码

#include <bits/stdc++.h>

using namespace std;

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--) {
        long long a, b, c;
        cin >> a >> b >> c;
        cout << a + b + c << ' ' << b + c << ' ' << c << '\n';
    }
    return 0;
}

C

题解

知识点：模拟，排序。

通过排序完数组和原来的对比数组，找到第一组两个在同一行需要交换位置的点，如果超过2个同一行的需要交换的点说明一次交换不可行直接输出-1，如果为0个则不需要交换，设置任意一个点作为两个交换的点(即不交换)。

在确认两个交换点之后，对原数组每行进行交换，每行交换之后判断是否是排序好的，如果有一行不是说明不可行输出-1，否则为答案。

时间复杂度 \(O(nm \log m)\)

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

代码

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

using namespace std;

bool solve() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> a(n, vector<int>(m)), b(n, vector<int>(m));
    for (int i = 0;i < n;i++) {
        for (int j = 0;j < m;j++) {
            cin >> a[i][j], b[i][j] = a[i][j];
        }
    }
    for (int i = 0;i < n;i++) {
        sort(b[i].begin(), b[i].end());
    }
    int pos1 = -1, pos2 = -1;
    for (int i = 0;i < n;i++) {
        for (int j = 0;j < m;j++) {
            if (a[i][j] != b[i][j]) {
                if (!~pos1) pos1 = j;
                else if (!~pos2) pos2 = j;
                else return false;
            }
        }
        if (~pos1) break;
    }
    if (!~pos1) pos2 = pos1 = 0;
    for (int i = 0;i < n;i++) {
        swap(a[i][pos1], a[i][pos2]);
        if (!is_sorted(a[i].begin(), a[i].end())) return false;
    }
    cout << pos1 + 1 << ' ' << pos2 + 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-1-i-a[i]\) 排序的前 \(k\) 小值的点，或者说是 \(i+a[i]\) 排序的前 \(k\) 大值的点。

意识流证明：

\(n-1-i-a[i]\) 可以理解为跳过一个点后的代价改变量（\(i+a[i]\) ，即 \(a[i]-(n-1-i)\) 可以理解为跳过一个点的代价减少量），而只要选改变量最小的 \(k\) 个点，并且减去在每个跳过的点因为之前跳过点产生的额外代价（跳过的点不应该有代价）共 \(k(k-1)/2\) ，可以得到一个最小实际改变量（实际上一定存在一种方法使其小于 \(0\) ，这也说明了最优方法一定把 \(k\) 次跳过机会用完），加上改变量就能使总代价最小。

数学证明：微扰法。

假设方案不是跳过最小改变量的 \(k\) 个位置，则存在更优方案。

首先，存在某个位置 \(i\) 没有被跳过,某个位置 \(j\) 被跳过，且有 \(n-1-i-a[i]<n-1-j-a[j]\)，即 \(i+a[i]>j+a[j]\) ，有两种情况\(i<j\) 和 \(i>j\) 。

当 \(i<j\) 时，从 \(a[j]\) 到 \(a[i]\) 会让 \(j-i\) 个位置代价加一，并且答案减去 \(a[i]\) 加上 \(a[j]\)，又因为 \(i+a[i]>j+a[j]\) , 可以得到改变量 \(a[j] - a[i] + j - i < 0\) ，改变一定更优。\(i>j\) 的情况同理。

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

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

代码

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

using namespace std;

int a[200007];

bool solve() {
    int n, k;
    cin >> n >> k;
    ///显然k个跳点都选上是最小的必要条件
    ll ans = -1LL * k * (k - 1) / 2;///每个跳过的点都要减掉之前跳过点产生的额外代价，因为跳过的点没有代价
    for (int i = 0;i < n;i++) cin >> a[i], ans += a[i], a[i] = n - 1 - i - a[i];///n-i-a[i]代表跳过这个点相对于不跳过会产生多少代价
    sort(a, a + n);///用于挑选前k个产生代价最小的点跳过
    for (int i = 0;i < k;i++) ans += a[i];///跳过产生的代价变化
    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;
}

E

题解

知识点：数据结构，贪心。

MEX：序列中最小未出现的自然数（包括0）。

例如，\(MEX(\{ 0,1,2,4,5 \})=3\) ， \(MEX(\{ 1,2,4,5 \}) = 0\) 。

观察\(DIFF - MEX\) 的结果，发现 \(MEX\) 数之前的数必然都出现，则种类数一定和 \(MEX\) 一样，因此结果就是大于 \(MEX\) 的数的种类数。

我们发现，当通过修改数字使得 \(MEX\) 增大时，\(DIFF\) 必然是不增的，因此可以先考虑在 \(k\) 次操作得到尽可能大的 \(MEX\) ，而数组长度为 \(n\) ，则必然可以通过修改使在 \(n\) 以内的所有 \(MEX\) 都能得到，所以可以从 \(0\) 开始遍历 ，若存在该数字则继续，否则通过一次操作得到这个数字，这样就可以得到 \(k\) 次操作后最大可能的 \(MEX\) 了，这样操作得到的 \(MEX\) 可能会大于 \(n\) 但不需要限制操作次数使其合法，因为大于等于 \(n\) 在之后处理中也都能得到正确结果 \(0\) 。

得到最大的 \(MEX\) 后，只要考虑操作比 \(MEX\) 大的就行（即使可能用不完 \(k\) 次），首先因为大于 \(MEX\) 的数字种类即是答案，所以优先取完其尽可能多的种类能直接降低答案，其次 \(MEX\) 是操作 \(k\) 次内的必然结果，无论如何都能在 \(k\) 次内达到，而大于 \(MEX\) 的数字种类即是答案，那么只考虑 \(k\) 次操作后（可能不到 \(k\) 次就取完了，剩下的操作可以理解为用小于 \(MEX\) 的数补全，从而也能达到 \(MEX\) ，但不改变答案 \(0\)）这些数的种类即可。特别地，最大 \(MEX\) 在取的时候可能大于等于其最大可能值 \(n\) ，即最后大于 \(MEX\) 数的种类必然为\(0\) ，也即 \(k\) 次操作内必然取完大于 \(MEX\) 的数，答案也为 \(0\) ，所以在之前的操作不需要通过限制操作次数来限制 \(MEX\) 。

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

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

代码

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

using namespace std;

bool solve() {
    int n, k;
    cin >> n >> k;
    map<int, int> m;///用于元素与数量映射
    for (int i = 0;i < n;i++) {
        int tmp;
        cin >> tmp;
        m[tmp]++;
    }
    int mex = 0;
    for (int i = 0, kk = k;;i++) {
        if (!m.count(i)) {
            if (kk) kk--;
            else {
                mex = i;
                break;
            }
        }
    }
    priority_queue<int, vector<int>, greater<int>> pq;
    for (auto i : m) if (i.first > mex) pq.push(i.second);
    while (!pq.empty() && k >= pq.top()) { ///答案等于大于mex的元素种类，所以k<最小个数元素时，不用继续，此种类补全k次后不会消失，留着就行
        k -= pq.top();
        pq.pop();
    }
    cout << pq.size() << '\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;
}