EPIC Institute of Technology Round Summer 2024 A~F2

最新推荐文章于 2024-07-21 21:08:59 发布

AC-Panda

最新推荐文章于 2024-07-21 21:08:59 发布

阅读量495

点赞数 23

分类专栏： codeforces题解文章标签：算法 ACM-ICPC OI codeforces c++

本文链接：https://blog.csdn.net/Code_Shark/article/details/140584653

版权

codeforces题解专栏收录该内容

88 篇文章 7 订阅

订阅专栏

A. Upload More RAM （贪心）

题意：

你想上传 $n$ $GB$ 的 $R A M$ 。每秒，你能上传 $0$ 或 $1$ $GB$ 的 $R A M$ 。但是，你的网络速度有限制：在任何连续 $k$ 秒内，你最多只能上传 $1$ $GB$ 的 $R A M$ 。

输出上传 $n$ $GB$ 的 $R A M$ 所需的最少秒数。

分析：

我们贪心地叠加，答案为 $\times k+1$

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, k;
        cin >> n >> k;
        cout << (n - 1) * k + 1 << endl;
    }
    return 0;
}

B.K-Sort （思维）

题意：

给出一个长度为 $n$ 的整数数组 $a$ 。

你可以多次（可能是零次）执行以下操作：

选择一个整数 $k$ ，使得 $\le k \le n$ ，并支付 $k + 1$ 个硬币。
然后，选择 $k$ 个索引 ${i_x}$ 。
然后，对于从 $1$ 到 $k$ 的每个 $x$ ，将 $a_{i_x}$ 增加 $1$ 。

找到使 $a$ 非降序所需的最小硬币数量。

分析：

令 $p_i=max(0,a_{i-1}-a_i)$ ，那么我们得到一个数组 $p$ ，将其升序排序，将题目转化为将数组 $p$ 全变为 $0$ ，操作的代价为 $\sum_{i=1}^n p_i +max(p_i)$ 。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<LL> a(n);
        for (int i = 0; i < n; i++)
            cin >> a[i];
        vector<LL> p{0};
        for (int i = 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                p.push_back(a[i - 1] - a[i]);
                a[i] = a[i - 1];
            }
        }
        sort(p.begin(), p.end());
        LL ans = 0;
        LL maxval = 0;
        for (int i = 0; i < p.size(); i++) {
            maxval = max(maxval, p[i]);
            ans += p[i];
        }
        ans += maxval;
        cout << ans << endl;
    }
    return 0;
}

C.Basil’s Garden （思维）

题意：

一排有 $n$ 朵花，其中第 $i$ 朵花的初始高度为 $h_i$ 米。
每一秒，风都会从左侧吹来，导致一些花的高度降低。
具体来说，每一秒，对于从 $1$ 到 $n$ 的每个 $i$ ，按此顺序，会发生以下情况：

如果是 $i = n$ 或 $h_i > h_{i + 1}$ ，则 $h_i$ 的值变为 $max(0, h_i - 1)$ 。

询问对于所有 $\le i \le n$ ，第一次出现 $h_i=0$ 之前需要经过多少秒？

分析：

设 $f_i$ 表示第 $i$ 朵花的高度第一次变为 $0$ 的时间，那么对于第 $i$ 朵花：

若其高度小于等于第 $i + 1$ 朵，则其高度变为 $0$ 的时间为第 $i + 1$ 朵高度变为 $0$ 的时间 $+ 1$
若其高度大于第 $i + 1$ 朵，则其高度变为 $0$ 的时间为第 $i + 1$ 朵高度变为 $0$ 的时间 $+ 1$ 和其高度之间的最大值。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 3e5 + 10;
int n;
int a[N];

int main() {
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        a[n + 1] = 0;
        for (int i = 1; i <= n; ++i)
            cin >> a[i];
        int ans, num;
        ans = num = 1ll * a[n];
        for (int i = n - 1; i; --i)
            if (a[i + 1] >= a[i])
                num++, ans = max(ans, num);
            else {
                num = max(1ll * a[i] - 1ll * (num - a[i + 1] + 1), 1ll * a[i + 1]) + 1ll * (num - a[i + 1] + 1);
                ans = max(ans, num);
            }
        cout << ans << endl;
    }
    return 0;
}

D.World is Mine （dp）

题意：

$A l i ce$ 和 $B o b$ 正在玩游戏。最初，有 $n$ 个蛋糕，第 $i$ 个蛋糕的美味值为 $a_i$ 。

$A l i ce$ 和 $B o b$ 轮流吃蛋糕， $A l i ce$ 先吃：

轮到 $A l i ce$ 选择并吃掉满足下列条件的一块蛋糕，其美味度严格大于她之前吃过的任何蛋糕的最大美味度。请注意，在第一轮，她可以选择任何蛋糕。
轮到 $B o b$ 选择并吃掉任何剩下的一块蛋糕。

当当前玩家吃不到合适的蛋糕时，游戏结束。让 $x$ 为 $A l i ce$ 吃过的蛋糕数量。然后， $A l i ce$ 想要最大化 $x$ ，而 $B o b$ 想要最小化 $x$ 。

计算如果两个玩家都发挥最佳的话，爱丽丝会吃多少个蛋糕。

分析：

$A l i ce$ 的最优策略肯定是永远选可以选的数里最小的，那么 $B o b$ 的策略就是应该取完一些数字，使得 $A l i ce$ 选不着这些数字。令 $d p [i] [j]$ 表示对于前 $i$ 个数字,后手取完了其中 $j$ 个,至少需要多少次操作。
假设前 $i$ 个数字共有 $x$ 个,取走 $j$ 个数字中的共有 $y$ 个,那么必须要有 $\ge y$ 才可以,否则不能在 $A l i ce$ 取之前完成所有操作。用 $d p$ 转移即可。

代码：

#include <bits/stdc++.h>

using namespace std;
const int INF = 1e9;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> tmp(n + 1);
        for (int i = 0; i < n; i++) {
            int x;
            cin >> x;
            tmp[x] += 1;
        }
        vector<int> cake;
        for (int i = 1; i <= n; i++) {
            if (tmp[i] > 0) {
                cake.push_back(tmp[i]);
            }
        }
        const int m = cake.size();
        vector<int> dp(m + 1, INF);
        dp[0] = 0;
        for (int i = 0; i < m; i++) {
            auto tmp1 = dp;
            for (int j = 0; j < i; j++) {
                if (dp[j] + cake[i] <= i - j) {
                    tmp1[j + 1] = min(tmp1[j + 1], dp[j] + cake[i]);
                }
            }
            dp.swap(tmp1);
        }
        int ans = INF;
        for (int i = 0; i <= m; i++) {
            if (dp[i] < INF / 2) {
                ans = min(ans, m - i);
            }
        }
        cout << ans << endl;
    }
    return 0;
}

E.Wonderful Tree! （dp）

题意：

给定一棵树，有 $n$ 个顶点，根节点为 $1$ 。第 $i$ 个顶点上写有一个整数 $a_i$ 。
让 $L$ 为 $v$ 的所有直接子节点的集合。如果对于所有 $L$ 不为空的顶点 $v$ ，满足

$a_v \le \sum_{u \in L}{a_u}.$

则称这棵树为奇妙树。
你可以选择任意顶点 $v$ 并将 $a_v$ 增加 $1$ 。
找到使给定的树变得奇妙树所需的最少操作数！
如果满足以下条件，则顶点 $u$ 称为顶点 $v$ 的直接子节点：

$u$ 和 $v$ 由一条边连接，并且
$v$ 位于从 $u$ 到树根的（唯一）路径上。

分析：

如果一个结点不满足要求，那么我们需要增加其儿子的值，但是增加儿子的值有可能导致儿子不满足要求，所以又要增加儿子的儿子的值。我们通过 $d p$ ，自底向上考虑，如果是叶子的父亲不满足要求，我们只需要增加叶子的值即可，一次只需要一个单位的代价。并且没有任何限制。
所以可以令父亲继承儿子的所有操作，只需要把儿子的所有操作代价加一即可（加上这个父亲结点的代价）。当需要操作时，贪心地使用代价最小的操作即可。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int INF = 1e9;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        vector<int> a(n);
        for (auto &x: a)
            cin >> x;
        vector<int> d(n);
        vector<vector<int>> g(n);
        for (int i = 1; i < n; i++) {
            int x;
            cin >> x;
            x--;
            g[x].push_back(i);
            d[i] = d[x] + 1;
        }
        vector<LL> b(n);
        for (int v = 0; v < n; v++) {
            if (g[v].empty()) {
                b[v] = INF;
            } else {
                b[v] = -a[v];

                for (int u: g[v]) {
                    b[v] += a[u];
                }
            }
        }

        LL ans = 0;
        for (int v = n - 1; v >= 0; v--) {
            queue<int> q;
            q.push(v);
            while (!q.empty()) {
                int i = q.front();
                q.pop();
                for (int u: g[i]) {
                    LL delta = min(-b[v], b[u]);
                    if (delta > 0) {
                        b[v] += delta;
                        b[u] -= delta;
                        ans += delta * (d[u] - d[v]);
                    }
                    q.push(u);
                }
            }
        }

        cout << ans << endl;
    }
    return 0;
}

F1. Interesting Problem (Easy Version) （dp）

题意：

给出一个长度为 $n$ 的整数数组 $a$ 。
在一次操作中，你可以执行以下两步过程：

选择一个索引 $i$ ，使得 $\le i < |a|$ 和 $a_i = i$ 。
从数组中删除 $a_i$ 和 $a_{i+1}$ ，并连接剩余部分。

找出你可以执行上述操作的最大次数。

分析：

我们观察可以发现，消除的每一个区间,都是以类似括号序列的形式消去的,并且当前区间能被操作多少次只跟其之前的区间操作了多少次有关。令 $d p 1 [l] [r] [x]$ 表示之前的区间操作了 $x$ 次时 $[l, r]$ 的答案， $d p 2 [l] [r] [x]$ 表示之前的区间操作了 $x$ 次时 $[l, r]$ 完全消去的答案。在计算 $d p 2$ 的时候，如果此时选择要消除的位置为 $l, j$ ，之前的操作数为 $x$ ，那么需要计算 $d p 2 [l] [j] [x]$ 。并且不能直接把 $x$ 传到下一层中，因为如果 $x$ 次操作全部用掉，那么最外面这一层 $[l, j]$ 存在无法消去的可能。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 105;
const int INF = 1e9;
int tmp1[N][N][N], tmp2[N][N][N];
int a[N];

int solve2(int l, int r, int x) {
    if ((r - l + 1) % 2 != 0)
        return -INF;
    if (r - l + 1 == 0)
        return 0;
    if (~tmp2[l][r][x])
        return tmp2[l][r][x];
    int ans = -INF;
    if (a[l] % 2 == l % 2 and a[l] <= l and a[l] >= l - 2 * x) {
        int cur = (l - a[l]) / 2;
        for (int j = l + 1; j <= r; j += 2) {
            int t = solve2(l + 1, j - 1, cur);
            if (t < 0)
                continue;
            int s = t + 1;
            t = solve2(j + 1, r, x + s);
            if (t < 0)
                continue;
            s += t;
            ans = max(ans, s);
        }
    }
    return tmp2[l][r][x] = ans;
}

int solve1(int l, int r, int x) {
    if (l >= r)
        return 0;
    if (~tmp1[l][r][x])
        return tmp1[l][r][x];
    int ans = 0;
    ans = max(solve1(l + 1, r, x), solve1(l, r - 1, x));
    for (int i = l; i < r; i++) {
        int t = solve1(l, i, x);
        ans = max(ans, t + solve1(i + 1, r, x + t));
    }
    for (int j = l + 1; j <= r; j += 2) {
        int t = solve2(l, j, x);
        if (t < 0)
            continue;
        int s = t;
        s += solve1(j + 1, r, x + t);
        ans = max(ans, s);
    }
    return tmp1[l][r][x] = ans;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        memset(tmp1, -1, sizeof(tmp1));
        memset(tmp2, -1, sizeof(tmp2));
        cout << solve1(1, n, 0) << endl;
    }
    return 0;
}

F2. Interesting Problem (Hard Version) （dp）

题意：

给出一个长度为 $n$ 的整数数组 $a$ 。
在一次操作中，你可以执行以下两步过程：

选择一个索引 $i$ ，使得 $\le i < |a|$ 和 $a_i = i$ 。
从数组中删除 $a_i$ 和 $a_{i+1}$ ，并连接剩余部分。

找出你可以执行上述操作的最大次数。

分析：

令 $dp_i$ 表示前 $i$ 个数字最多能消去多少个数字，我们枚举下一个需要删除的段进行删除。我们首先要计算 $f [l] [r]$ 表示想要删除完 $[l, r]$ 至少需要删除多少个元素，并以此来判断某一段能否被删除。接下来就可以用区间 $d p$ 的思想去解决问题。

代码：

#include <bits/stdc++.h>

using namespace std;
const int N = 805;
const int INF = 1e9;
int a[N];
int f[N][N];

int solve1(int l, int r) {
    if (r - l + 1 == 0)
        return 0;
    if (a[l] % 2 != l % 2 or a[l] > l)
        return INF;
    if (~f[l][r])
        return f[l][r];
    int ans = INF;
    int tmp = (l - a[l]) / 2;
    for (int i = l + 1; i <= r; i += 2) {
        if (solve1(l + 1, i - 1) > tmp)
            continue;
        int t = solve1(i + 1, r);
        ans = min(ans, max(tmp, t - (i - l + 1) / 2));
    }
    return f[l][r] = ans;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        memset(f, -1, sizeof f);
        vector<int> g(n + 1);
        for (int i = 0; i < n; i++) {
            g[i + 1] = max(g[i + 1], g[i]);
            for (int j = i + 2; j <= n; j += 2) {
                if (solve1(i + 1, j) <= g[i]) {
                    g[j] = max(g[j], g[i] + (j - i) / 2);
                }
            }
        }
        cout << g[n] << endl;
    }
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。

AC-Panda

关注

23
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
EPIC Institute of Technology Round Summer 2024 A~F2

你想上传nGB的RAM。每秒，你能上传0或1GB的RAM。但是，你的网络速度有限制：在任何连续k秒内，你最多只能上传1GB的RAM。输出上传nGB的RAM所需的最少秒数。
复制链接

扫一扫