Codeforces Round #702 (Div. 3) 题解

写在前边

链接：Codeforces Round #702 (Div. 3)

比较简单，但是总是感觉脑子有点转不过弯来。

A. Dense Array

链接：A题链接

题目大意:

在数组中插入若干个数，使得\(\cfrac{max(a[i], a[i + 1])}{min(a[i], a[i + 1])} \leq 2\)，问至少需要插入多少个数。

思路：

既然是相邻，那么只需要顺序模拟即可，每次把\(min(a[i], a[i + 1])×2\), 直到它的两倍大于等于\(2\)停止，求累计次数。

代码

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

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

const int N = 55;

void solve() {
    int n;
    int a[N];
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

    int res = 0;
    for (int i = 1; i < n; i++) {
        if (max(a[i], a[i - 1]) > 2 * min(a[i], a[i - 1])) {
            int m = min(a[i], a[i - 1]);
            while (m * 2 < max(a[i], a[i - 1])) {
                res++;
                m *= 2;
            }
        }
    }
    printf("%d\n", res);
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }
    return 0;
}

B. Balanced Remainders

链接：B题链接

题目大意:

给定一个有\(n\)(n可以被3整除)个元素的数组，\(c_0,c_1,c_2\)分别表示数组中元素模\(3\)后的余数为\(0， 1， 2\)的数的个数，现在每次操作可以使一个数加\(1\),问最少经过几次操作可以使得\(c_0 == c_1 == c_2\)

思路：

可以发现，\(c_0, c_1, c_2\)之间可以进行单一方向的转移，例如模\(3\)余数为\(0\)的数加\(1\)后余数变为\(1\)，余数为\(1\)的数加\(1\)后余数变为\(2\)，余数为\(2\)的数加\(1\)后余数变为\(0\)

，于是问题就转化成了转移多少次的问题，相邻的转移又一定是最优的。

代码

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

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

const int N = 3e4 + 10;
int a[N];

void solve() {
    int n;
    scanf("%d", &n);
    unordered_map<int, int> hash;
    int cnt0 = 0, cnt1 = 0, cnt2 = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        hash[a[i] % 3]++;
    }

    int aver = n / 3;
    int res = 0;
    while (1) {
        if (hash[1] == hash[2] && hash[1] == hash[0] && hash[0] == hash[2]) {
            break;
        }
        if (hash[1] < aver) {
            hash[0] -= (aver - hash[1]);
            res += (aver - hash[1]);
            hash[1] = aver;
        }
        if (hash[2] < aver) {
            hash[1] -= (aver - hash[2]);
            res += (aver - hash[2]);
            hash[2] = aver;
        }
        if (hash[0] < aver) {
            hash[2] -= (aver - hash[0]);
            res += (aver - hash[0]);
            hash[0] = aver;
        }
    }
    printf("%d\n", res);
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }
    return 0;
}

C. Sum of Cubes

链接：C题链接

题目大意:

判断一个数\(x\)是否满足\(x = a^3 + b^3 \, (a, b \geq 1)\)

思路：

因为数据最大为\(10^{12}\)，所以\(a,b \in [1, 10^4)\)，所以一种做法是预处理出\(a^3\)，然后再\(O(10^4)\)枚举\(b\)，\(O(1)\)查找\(a^3\)。

另一种方法是\(O(10^4)\)枚举\(a\),二分\(b\)，复杂度\(O(10^4 * log 10^4)\)

代码

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

using namespace std;

#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

void solve() {
    LL x;
    scanf("%lld", &x);
    LL t1;
    for (LL i = 1; i <= 10000; i++) {
        LL l = 1, r = 10000;
        while (l < r) {
            LL mid = l + r >> 1;
            LL sum = i * i * i + mid * mid * mid;
            if (sum > x) r = mid;
            else if (sum < x) l = mid + 1;
            else {
                puts("YES");
                return;
            }
        }
    }
    puts("NO");
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }
    return 0;
}

D. Permutation Transformation

链接：D题链接

题目大意:

给定一个数组，用其数据建一棵树，最大的数始终作为树根，树根左侧数构成左子树，右边的数构成右子树，同理选大的作为子树的根，求每个数在树中所处的深度。

思路：

\(DFS\)

代码

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

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

const int N = 110;
int a[N];
int res[N];
int n;

void build(int l, int r, int depth) {
    if (l > r) return;

    int idx = l;
    for (int i = l; i <= r; i++) {
        if (a[i] > a[idx]) idx = i;
    }
    res[idx] = depth;
    build(l, idx - 1, depth + 1);
    build(idx + 1, r, depth + 1);
}  

void solve() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

    build(0, n - 1, 0);

    for (int i = 0; i < n; i++) printf("%d ", res[i]);
    puts("");
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }
    return 0;
}

E. Accidental Victory

链接：E题链接

题目大意:

\(n\)个玩家，每人都有一个点数，两个人对战，点数大的获胜，相同点数随机一人获胜，获胜后获得败者的点数，问有哪些人会有获胜的可能性。

思路：

一个人要想获胜，那么肯定需要干掉所有的人才可以，首先按照点数给人排序，我们发现对于第i个人它可以直接获得它之前人的所有点数，这里可以用前缀和处理，如果可以赢得比赛，那么他后边的人也一定能赢得比赛，因为他后边的人可以获得更多的点数，所以可以发现有二段性，因此我们可以直接二分出第一个获胜的人，剩下的直接输出即可。

代码

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

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'
#define score first
#define num second

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

const int N = 2e5 + 10;
LL b[N];
int n;
PII a[N];

bool check(int x) {
    LL t = b[x];
    for (int i = x + 1; i <= n; i++) {
        if (t >= a[i].score) {
            t += (LL) a[i].score;
            continue;
        }
        else return false;
    }
    return true;
}

void solve() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i].score);
        a[i].second = i;
    }
    sort(a + 1, a + n + 1);

    for (int i = 1; i <= n; i++) b[i] = b[i - 1] + (LL) a[i].score;
    int l = 1, r = n;
    while (l < r) {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }
    vector<int> res;
    for (int i = l; i <= n; i++) res.push_back(a[i].num);
    sort(res.begin(), res.end());

    printf("%d\n", n - l + 1);
    for (auto &it : res) printf("%d ", it);
    puts("");
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }

    return 0;
}

F. Equalize the Array

链接：F题链接

题目大意:

设\(cnt_x\)为数组中每个数的出现次数，如果一个数组中的数只有\(C\)次或者\(0\)次可以认为这个数组是漂亮的，所以我们现在要做的就是删掉某些数使得这个数组是漂亮的。

思路：

按照题意，\(cnt_x\)小于\(C\)的\(x\)那么全部删除，大于\(C\)的需要删除\(cnt_x - C\)个，所以有：

\[删除个数 = \sum\limits_{cnt_x < C} cnt_x + \sum\limits_{cnt_x >= C} (cnt_x - C)
\]

看到这个公式能想到什么，当然是前缀和。

但是有一个问题，\(C\)的范围一定是某个数的出现次数吗，如果不是，那么就没法用前缀和做了，那怎么证明呢，如果\(C\)不是某个数的出现次数,我们令某个刚好大于\(C\)的次数为\(Y\)，可以发现，\(\sum\limits_{cnt_x < C} cnt_x\)没有发生变化，而大于\(\sum\limits_{cnt_x >= C} (cnt_x - C) > \sum\limits_{cnt_x >= Y} (cnt_x - Y)\)，这样于是删除个数变大了，所以我们根本不需要考虑如果\(C\)不是某个数的出现次数这种情况。

有了前缀和\(presum\)，根据公式，左边就有\(left = presum[i - 1]\), 右边就有\(right = (presum[last] - presum[i - 1]) - (last - i + 1) * cnt[i]\)，于是更新答案即可。

代码

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

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

const int N = 2e5 + 10;
int n, c;
LL presum[N];

bool cmp(int a, int b) {
    return a > b;
}

void solve() {
    scanf("%d", &n);
    map<LL, LL> mp;
    for (int i = 0; i < n; i++) {
        scanf("%d", &c);
        mp[c]++;
    }

    vector<LL> cnt; //计数 数字出现的次数
    for (auto &it : mp) cnt.push_back(it.second);
    cnt.push_back(0);
    sort(cnt.begin(), cnt.end()); 

    LL res = n;
    int last = cnt.size() - 1;
    for (int i = 1; i < cnt.size(); i++) presum[i] = presum[i - 1] + cnt[i];
    for (int i = 1; i <= last; i++) {
        LL left = presum[i - 1], right = (presum[last] - presum[i - 1]) - (last - i + 1) * cnt[i];
        res = min(res, left + right);
    }
    printf("%d\n", res);
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }

    return 0;
}

G - Old Floppy Drive

链接：G题链接

题目大意:

现在有个含有\(n\)个元素的数组\(a\)，且有一个指针指向\(a\)的初始，还有一个\(m\)个元素的数组\(x\)，对于每一个\(x_i\)，指针会不停的运动，如果数组末尾那么它会重新指会第一个元素继续运动，直到指针走过的数组所有元素的和\(≥x\)，那么指针停止，求指针的运动次数。

思路：

设数组总和为\(S\)，前缀和为\(preSum\)，运行一次的时间是\(T\)，那么运行\(t\)秒，那么走过的总和\(Sum\)：

\[Sum = \lfloor \cfrac{t}{T} \rfloor * S + preSum \, [t \, mod \, T]
\]

由此可见，如果\(S \leq 0\) 并且 \(\max\limits_{i = 1}^n \, preSum[i] < x\)那么指针将永远运行下去不会停止，那么直接输出\(-1\)即可。

然后就分别求磁盘转动的整圈数，然后再加上\(\max\limits_{i = 1}^n \, preSum[i] \geq x\)的最小位置\(i\)，可以知道，对于磁盘的转动整圈数不得少于\(\lceil \frac{x - \max\limits_{i = 1}^n \, preSum[i] \, }{S} \rceil\)，少于转不到，多于的话也就不能保证答案是最小位置了。

最后就需要找到\(\max\limits_{i = 1}^n \, preSum[i] \geq x\)的位置\(i\)了，可以用二分，注意这个前缀和并不是随随便便的前缀和，处理它的时候保证它是单调递增的且\(＞0\),如果小于等于\(0\)那么对总和\(Sum\)没有任何贡献，并且单调递增才能保证我们可以得到那个刚好\(\max\limits_{i = 1}^n \, preSum[i] \geq x\)的位置\(i\)，而这一步我们可以用二分lower_bound寻找即可。

代码

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

using namespace std;

#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
#define endl '\n'

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

LL gcd(LL a, LL b) {
    return b ? gcd(b, a % b) : a;
}

const int N = 2e5 + 10;
int n, m;
LL presum[N];
LL preInd[N]; //记录前缀的坐标

void solve() {
    int idx = 0; //当前坐标
    LL allsum = 0, c;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &c);
        allsum += c;
        if (allsum > presum[idx]) {
            presum[++idx] = allsum;
            preInd[idx] = i;
        }
    }

    for (int i = 1; i <= m; i++) {
        LL x;
        scanf("%lld", &x);
        if (presum[idx] < x && allsum <= 0) {
            printf("%d ", -1);
            continue;
        }
        LL needspins = 0;
        if (presum[idx] < x) {
            needspins = (x - presum[idx] + allsum - 1) / allsum;
        }
        x -= needspins * allsum;
        LL q = lower_bound(presum + 1, presum + idx + 1, x) - presum;
        LL res = needspins * n + preInd[q] - 1; //因为前缀从1开始，那么减去1
        printf("%lld ", res);
    }
    puts("");
}

int main()
{
    //ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    int t;
    scanf("%d", &t);
    while (t--) {
        solve();
    }

    return 0;
}