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;
}