Codeforces Round #696 (Div. 2) (A~C题解)

写在前边

链接:Codeforces Round #696 (Div. 2)

A. Puzzle From the Future

链接：A题链接

题目大意:

给定一个\(a\),\(b\)，\(d = a + b\)，例如：\(a = 0101\), \(b= 1111\), \(d = 1212\)，但是d如果有连续重复的数字那么会省掉，假如\(a + b = 12211\)，则\(d = 121\)，现在已知\(a\)，\(b\)丢失了，要求求出一个\(b\)使得\(d\)最大。

思路：

首先要使得\(d\)最大化，\(b\)的第一位必定是\(1\)，剩下的直接从前到后模拟即可，若\(a_i + b_i == d[i-1]\)那么\(d\)会减小，因此“反其道而行之即可”。

代码:

#include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define PLL pair<long, long>

typedef long long LL;
typedef unsigned long long ULL;

void solve() {
    string s, res = "1";
    int n;
    cin >> n;
    cin >> s;
    for (int i = 1; i < s.size(); i++) {
        if (((s[i]-'0') + 1) == (s[i - 1] - '0' + res[i - 1] - '0')) {
            res += '0';
        } else {
            res += '1';
        }
    }

    cout << res << endl;
}

int main()
{
    int t;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}

B. Different Divisors

链接：B题链接

题目大意:

给定一个\(d\)，求\(a\)，要求\(a\)至少有\(4\)个约数，并且约数两两之间的至少差\(d\)，并且要求\(a\)是可行方案中中的最小值。

思路：

\(\quad\) 题目要求四个约数，那么让其只有四个约数即可，即\(1 \quad p \quad q \quad pq\)，\(p >= 1 + d\), \(q >= p + d\)，因此\(p\)就是大于\(d + 1\)的最小质数，\(q\)就是大于\(p + d\)的最小质数，那么\(p * q\)就是满足条件\(a\)。

证明：

\(\quad\) 若\(p\)是一个\(>=1+d\)合数，那么\(1 -- p\)之间必定还会会有一个\(p\)的约数\(p′\)，因为\(p′\)是\(p\)的约数，那么它必然也是\(a\)的约数这就使得\(p′-1 < d\)，不满足约数之间至少差\(d\)的条件，因此矛盾。

\(\quad\) 若\(p\)不是最小质数，设其为\(p′\)，另一个为\(q′\)，那么\(p′ * q′ > p*q\)，因此\(p′\)、\(q′\)并不是最优解。

综上：\(p\)为\(p >= 1 + d\)的最小质数与\(q\)为\(q >= p + d\)最小质数为最优解。

代码:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define PLL pair<long, long>

typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;

const int N = 25e3 + 10;
int primes[N], cnt;
bool st[N];

void get_primes() {
    for (int i = 2; i <= N; i++) {
        if (!st[i]) {
            primes[cnt++] = i;
        }
        for (int j = 0; primes[j] <= N / i; j++) {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) {
                break;
            }
        }
    }
}

void solve() {
    int d;
    cin >> d;
    int p, q, pcnt = 0;
    for (pcnt; pcnt <= cnt; pcnt++) {
        if (primes[pcnt] - 1 >= d) {
            p = primes[pcnt];
            break;
        }
    }
    for (int i = pcnt; i <= cnt; i++) {
        if (primes[i] - p >= d) {
            q = primes[i];
            break;
        }
    }
    cout << p * q << endl;
}

int main()
{
    int t;
    cin >> t;
    get_primes();
    while (t--) {
        solve();
    }

    return 0;
}

C. Array Destruction

链接：C题链接

题目大意:

例如，如果最初\(a=[3,5,1,2]\)，则可以选择\(x=6\)。然后你可以选择第二个和第三个元素的总和\(5+1=6\)，并抛出它们。在这个运算之后，\(x\)等于\(5\)，数组中有两个元素：\(3\)和\(2\)。你可以在下次操作时把它们扔了，那么输出

YES
6
1 5
2 3

若无论如何数组内元素都无法清空，那么输出\(NO\)即可。

思路：

每次选最大的数作为x。

证明:

假设\(a_i < a_j < a_k\),不选\(a_j\)来构造x，那么即\(a_i + a_j = x\),此后\(x = a_j\)，之后无论如何都消除不掉\(a_k\)，因此每次选最大数作为x即可。

那么第一次除了选最大的数作为下一轮的x，另一个数就需要枚举所有可能，直到枚举到一个可以消掉所有数的情况。明白了这一点那么剩下的只需要模拟即可，可以用\(multiset\)，因为其查找删除插入操作都是\(O(logn)\)，若不用\(multiset\)则手写二分查找即可，最时间复杂度:\(O(n^2logn)\)

自己的错误:写了一晚上，但最后还是\(TLE2\)告终，其实我已经知道了每次要选最大值了，但还是用双指针来搜哪两个数等于\(x\)，由于答案唯一，因此搜的结果是对的，但是导致\(O(n^3)\)被卡，应该直接确定数组中还剩下的最大数，然后剩下的小数直接用二分搜就好了。

代码:

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <set>

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define PLL pair<long, long>

typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;

vector<PII> check(VI all, int n, int x) {
    vector<PII> res;
    multiset<int> s;
    for (auto it : all) {
        s.insert(it);
    }
    for (int i = 0; i < n; i++) { //2*n个数，n个答案
        auto it1 = s.end();
        it1--;
        int y = x - *it1;
        s.erase(it1);
        auto it2 = s.find(y);
        if (it2 == s.end()) {
            return {};
        }
        s.erase(it2);
        res.push_back({y, x - y});
        x = max(x - y, y);
    }
    return res;
}

void solve() {
    int n;
    cin >> n;
    VI all;
    for (int i = 0; i < n * 2; i++) {
        int c;
        cin >> c;
        all.push_back(c);
    }
    sort(all.begin(), all.end());
    for (int i = 0; i < all.size() - 1; i++) { //枚举第一次操作的第二个数
        int x = all[i] + all[all.size() - 1]; //最大的一个
        vector<PII> res = check(all, n, x);

        if (res.size()) {
            cout << "YES" << endl;
            cout << x << endl;
            for (auto it : res) {
                cout << it.first << " " << it.second << endl;
            }
            return;
        }
    }
    cout << "NO" << endl;
}

int main()
{
    int t;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}