Educational Codeforces Round 103 (Rated for Div. 2) A~D题解
写在前边
A. K-divisible Sum
链接：A题链接
题目大意:
要求构造一个\(a\)数组使得\(a\)的和可以被\(k\)整除，在这个条件下让\(a\)中的最大值尽可能小。
思路：
我是这样想的，就是n张牌组成\(k\)，比如要求\(4\)张牌组成\(5， 6， 7， 8\)那么数组里最大的数最小肯定是\(2\)，但是如果\(8 < k \leq 12\)，那么就是\(3...\)了，而对于\(n < k\)的，我们想办法先让\(k > n\)，然后再与上面同理，所以我是分类讨论的：
当\(n < k\)时，那么最大的那个数就是\(k / n\)，如果无法整除则需要向上取整, 即\(k / n + (k \% n == 0 ? 0 : 1)\)。
当\(k = n\)时，那么最大的数最小肯定就是\(k / n = 1\)了。
当\(n > k\)时，那么我们可以先让\(k > n\)，即\(k = k * (n / k + (n \% k == 0 ? 0 : 1))\)，然后就与第一种情况同理了。
看到好多被\(hack\)的代码也是用这种思路，但是没有考虑无法整除向上取整的问题。
顺便新学了一招:\(q = \lceil \cfrac{n}{k} \rceil = \lfloor \cfrac{n + k - 1}{k} \rfloor\)，这样向上取整就用不着再用三目运算符啦！
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <unordered_map>
using namespace std;
#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;
void solve() {
LL n, k;
cin >> n >> k;
if (n > k) {
LL t1 = n / k;
k = k * (t1 + (n % k == 0 ? 0 : 1));
LL t2 = k / n;
cout << t2 + (k % n == 0 ? 0 : 1) << '\n';
return;
} else if (k == n) {
cout << 1 << endl;
return;
} else {
LL t2 = k / n;
cout << t2 + (k % n == 0 ? 0 : 1) << '\n';
}
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
B. Inflation
链接：B题链接
题目大意:
修改一个序列，让其通货膨胀系数不能超过\(k%\)，输出序列修改了多少。
而\(p_i\)的通货膨胀系数:\(k_i = \cfrac{p_i}{p_1 + p_2 + ... + p_{i-1}}\)，求出最小的修改数。
思路：
看到这个题因为枚举到后边的时候我们只关心前缀和就可以，不用具体关心前边某一个元素该怎么变化，所以就想到了前缀和，但是还是因为浮点数问题，其实类似问题已经在\(atc\)中一场比赛意识到了，遇到除法能不用小数就不用，比如判断是否合理的时候可以转化成乘法判断\(a[i] * 100 <= s[i-1] * k\)，最后终于修改的差不多了，还是有一个地方没有处理好，赛后才看到一个人代码恍然大悟，除不尽的时候应该向上取整的，可惜了。
向上取整还是用这种方法：\(q = \lceil \cfrac{n}{k} \rceil = \lfloor \cfrac{n + k - 1}{k} \rfloor\)
代码:
一开始的核心代码是这样的，用数组\(s\)来维护前缀和，但是每次都要再维护一下前缀和，明显增加了时间复杂度。
void deal(int k, LL temp) {
for (int i = k; i <= n; i++) {
s[i] += temp;
}
}
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] = s[i - 1] + a[i];
}
LL sum = 0;
for (int i = 2; i <= n; i++) {
if (a[i] * 100 <= s[i-1] * k) {
continue;
} else {
LL temp = (a[i] * 100 - k * s[i-1]) / k;
temp = (a[i] * 100 - k * s[i-1]) % k == 0 ? temp : temp + 1;
sum += temp;
deal(i - 1, temp); //处理前缀和
}
}
cout << sum << endl;
}
后来优化了很多，包括代码的长短，以及用一个变量来维护前缀和。
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <unordered_map>
#include <cmath>
using namespace std;
#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;
const int N = 110;
LL a[N];
LL n, k;
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
LL sum = 0, preSum = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] * 100 > preSum * k) {
LL temp = (a[i] * 100 - k * preSum + k - 1) / k;
sum += temp;
preSum += temp;
}
preSum += a[i];
}
cout << sum << endl;
}
int main()
{
//ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
C. Longest Simple Cycle
链接：C题链接
题目大意:
不描述原题了，有点难描述。。
思路：
因为我们求得一个圈的长度，而一个圈的右边必然右一条链组成，所以我们从第二条链往后枚举每一条链，对于每一个圈的右半部分长度就是\(c[i] + 1\)，而对于左半部分，如果\(a_i == b_i\)那么就说明右半部分重合到一点了，否则就是\(abs(a_i - b_i)\)，维护一个\(curlen\)以及一个\(lastlen\)，对于\(a_i != b_i\)的时候，我们可以判断一下左边的环与右边的环接起来是否会更大，如果更大就把中间的\(abs(a_i - b_i)\)去掉，即\(curlen = max(curlen, c[i] + 1 + lastlen - abs(a[i] - b[i]))\)，然后更新\(res\)以及\(lastlen\)即可
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <unordered_map>
using namespace std;
#define Inf 0x3f3f3f3f
#define PII pair<int, int>
#define P2LL pair<long long, long long>
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<long long> VLL;
typedef vector<int> VI;
const int N = 2e5 + 10;
LL c[N], a[N], b[N];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c[i];
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
LL res = 0, curlen = 0, lastlen = 0;
for (int i = 1; i < n; i++) {
curlen = c[i] + 1 + abs(a[i] - b[i]);
if (a[i] != b[i]) {
curlen = max(curlen, c[i] + 1 + lastlen - abs(a[i] - b[i]));
}
res = max(res, curlen);
lastlen = curlen;
}
cout << res << endl;
}
int main()
{
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
D. Journey
链接：D题链接
题目大意:
给定一组\(n\)个道路的方向，链接了\(n + 1\)个城市，旅游时只能按照道路方向旅游，同时走一次道路那么所有的道路就反向一次，比如原来道路方向只能是\(A->B\)，但是到\(B\)之后道路会反向，所以然后还可以从\(B\)返回\(A\)，求从每一个城市可以旅行到的最多城市。
思路：
一种是利用本题的性质，因为去还可以回来，所以可以说是一种无向边，但是并查集(\(DSU\)),\(BFS\),\(DFS\)代码我看了一上午，实在看不懂，想不明白。
于是用递推的方式做了，即用\(dpl_i\)表示\(i\)城市从\(i\)城市向左可以最多走到的城市标号，用\(dpr_i\)表示从\(i\)城市向右可以最多走到的城市标号，最后答案就是\(num_i = dpr_i -dpl_i +1\)，只不过要注意的细节比较多。
对于\(dpl_i\)：
- 如果不能向左走，那么:\(dpl_i = i\)。
- 如果能向左走一步那么:\(dpl_i = i-1\)
- 然后就可以直接转移了:\(dpl_i = dpl_{i-2}\)
对于\(dpr_i\)同理，从后向前递推即可。
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <vector>
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;
const int N = 3E5 + 10;
char s[N];
int n;
int dpl[N], dpr[N];
void solve() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n + 1; i++) {
dpl[i] = i;
}
for (int i = 1; i <= n + 1; i++) {
dpr[i] = i;
}
for (int i = 1; i <= n + 1; i++) {
if (i == 1 || s[i - 1] == 'R') { //向左走不动
dpl[i] = i;
} else if (i == 2 || s[i - 2] == 'L') { //向左只能走一格
dpl[i] = i - 1;
} else {
dpl[i] = dpl[i - 2];
}
}
for (int i = n + 1; i >= 1; i--) {
if (i == n + 1 || s[i] == 'L') {
dpr[i] = i;
} else if (i == n || s[i + 1] == 'R') {
dpr[i] = i + 1;
} else {
dpr[i] = dpr[i + 2];
}
}
for (int i = 1; i <= n + 1; i++) {
printf("%d ", dpr[i] - dpl[i] + 1);
}
puts("");
}
int main()
{
//ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
