Educational Codeforces Round 103 (Rated for Div. 2)（A-D题解）

最新推荐文章于 2024-06-05 23:48:41 发布

原创最新推荐文章于 2024-06-05 23:48:41 发布 · 262 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

算法入门专栏收录该内容

16 篇文章

订阅专栏

这篇博客详细介绍了四个算法问题的解决策略：K-K倍数求和问题采用简单计算求解；膨胀问题通过贪心算法实现；最长简单环问题通过动态规划找到最大环；旅行路径问题利用线性动态规划确定最远路径。每个问题都提供了清晰的思路和代码实现。

比赛没打，后续补的，本场A-D还是很简单的，没有多大思维性，感觉比较吃DP。

A. K-divisible Sum

题目链接：点击此处

只要追求平均就行。


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
int n, m,cnt;
int main() {
    int t;
    cin >> t;
    while (t--) {
        ll a, b;
        cin >> a >> b;
        ll c = ceil(a * 1.0 / b);
        cout << (ll)ceil(b*c*1.0/a) << endl;
    }
}

B. Inflation

题目链接：点击此处

样例的解释有点误导，其实只要贪心就行。

我们用 $sum_{i-1}$ 表示前 $i - 1$ 加上补充的前缀和， $a r r [i]$ 表示第 $i$ 个数。

假如 $100*arr[i]>sum_{i-1}*m$ 那么就要补充sum，ans也要加上补充值。

这样我们就确保在遍历到 $i$ 时，前面的都是可行的，后续的如 $i + 1$ 啥的，只和前缀和 $sum_{i}$ 有关，所以可以贪心。

#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
ll n, m,cnt;
ll arr[MAXN];
int main() {
    int t;
    cin >> t;
    while (t--) {
        cin >> n >> m;
        for (int i = 1;i <= n;i++) {
            cin >> arr[i];
        }
        ll sum = arr[1];
        ll ans = 0;
        for (int i = 2;i <= n;i++) {
            if (100 * arr[i] > sum*m) {
                ll nn= (ll)ceil((100 * arr[i] - sum * m) * 1.0 / m);
                ans += nn;
                sum += nn;
            }
            sum += arr[i];
        }
        cout << ans << endl;
    }
}

C. Longest Simple Cycle

题目链接：点击此处

题目看上去很难，仔细分析一下很简单。以为要扯到图论，结果啥也不是。

首先要最大，要是环（这里可以把环看成正方形）。然后我们从最右边的线开始向左dp（从左开始也行，从右边开始轻松一点，自己体会）。

设当前线为第 $i$ 根

dp表示从第 $n$ 根线枚举到 $i + 1$ 那根线时，右边部分的最大值。

那么我们要讨论以第 $i$ 根线作为左边的时候，环的长度。第 $i$ 根线和右边之间的连线可以够成环的上下两部份，对环总长度贡献了长度2，那么剩下的就是环的左边，即只要加上 $a b s (b [i] - c [i])$ ，就是如果把当前第 $i$ 线当作左边线。和maxn比较得到最大值。

然后更新dp值，即得到第 $n$ 根线枚举到 $i$ 那根线右边部分的最大值。一个是保留原来值，一个是放弃原来值，得到dp最大值。


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
ll n, m,cnt;
ll a[MAXN], b[MAXN], c[MAXN];
int main() {
    int t;
    cin >> t;
    while (t--) {
        cin >> n;
        ll maxn = 0;
        ll dp = 0;
        ll num = 0;
        for (int i = 1;i <= n;i++)cin >> a[i];
        for (int i = 1;i <= n;i++)cin >> b[i];
        for (int i = 1;i <= n;i++)cin >> c[i];
        dp = a[n]-1;
        for (int i = n;i >= 2;i--) {
            maxn = max(maxn, dp + 2 + abs(b[i] - c[i]));
            dp = max( dp+2 + min(b[i], c[i]) - 1 + a[i - 1] - max(b[i], c[i]), a[i - 1]-1);
            if (b[i] == c[i]) {
                dp = a[i-1]-1;
            }
        }
        cout << maxn << endl;
    }
}

D. Journey

题目链接：点击此处

只要知道一个点到左边的最远值和到右边的最远值是独立的就行。

因为你跑到最右边不能跑时，你返回来还是可以回到原点。然后这时候跑的路径数正好是偶数（一条路来回跑一下肯定是偶数），表示还是和开始一样，左边能跑的还是能跑，不能跑的还是不能跑。

这也就使得我们可以分开DP，dp跑左边最大值和dp跑右边最大值。

dp的话只是简单的线性dp,这里解释跑右边。如果第 $i$ 个点能跑到第 $i + 2$ 时，那么 $d p [i] = d p [i + 2] + 2$ ,如果不能那么 $d p [i]$ 就只有0和1两个选择。


#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<stdio.h>
#include<map>
#include<queue>
using namespace std;
typedef long long ll;
const int MAXN = 3e5 + 5;
const int MAXM = 1e6 + 5;
const ll mod = 1e9 + 7;
ll n, m,cnt;
char ch[MAXN];
int dp[MAXN];
int dp2[MAXN];
int main() {
    int t;
    cin >> t;
    while (t--) {
        cin >> n;
        for (int i = 1;i <= n;i++) {
            cin >> ch[i];
        }
        dp[1] = 0;
        dp2[n+1] = 0;
        for (int i = n;i >= 1;i--) {
            if (i <= n - 1) {
                if (ch[i] == 'R' && ch[i + 1] == 'L') {
                    dp2[i] = max(dp2[i],dp2[i + 2] + 2);
                }
            }
            if (ch[i] == 'R')dp2[i] = max(dp2[i], 1);
            else dp2[i] == 0;
        }
        for (int i = 1;i <= n;i++) {
            if (i >= 2) {
                if (ch[i] == 'L' && ch[i - 1] == 'R')dp[i+1] = max(dp[i+1], dp[i - 1] + 2);
            }
            if (ch[i] == 'L')dp[i+1] = max(dp[i+1], 1);
            else dp[i+1] == 0;
        }
        for (int i = 1;i <= n + 1;i++) {
            cout << dp[i] + dp2[i] + 1 << " ";
            dp[i] = dp2[i] = 0;
        }
        cout << endl;
    }
}