A.Primary Task(模拟)
题意:
德米特里在黑板上写下了 t t t个整数,这很好。他肯定自己丢失了其中一个重要的整数 n n n,这就不好了。
整数
n
n
n的形式是
10
10
10 ^
x
x
x(
x
≥
2
x\ge 2
x≥2),其中符号"^"
表示指数化。出了点差错,德米特里在写重要整数时漏掉了符号"^"
。例如,他应该写
105
105
105而不是
1
0
5
10^5
105,应该写
1019
1019
1019而不是
1
0
19
10^{19}
1019。
德米特里想知道黑板上的整数哪些可能是重要整数,哪些不可能。
分析:
判断一下字符串前两位是不是10
,除去前两位后后面的部分是不是一个大于等于2
的数即可。
代码:
#include<bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
if (s.length() <= 2) {
cout << "NO" << endl;
return;
}
if (!(s[0] == '1' && s[1] == '0')) {
cout << "NO" << endl;
return;
}
if (s[2] == '0') {
cout << "NO" << endl;
return;
} else if (s[2] == '1') {
if (s.length() == 3) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
B.Seating in a Bus(模拟)
题意:
在伯兰,一辆公共汽车由一排从 1 1 1到 n n n的 n n n个座位组成。乘客上车时请务必遵守这些规则:
- 如果车上没有空座位,乘客可以坐在任何空座位上;
- 否则,乘客应坐在至少有一个邻座空闲的座位上。换句话说,只有当 i − 1 i-1 i−1或 i + 1 i+1 i+1中至少有一个座位有人时,乘客才能坐在索引为 i i i( 1 ≤ i ≤ n 1\le i\le n 1≤i≤n)的座位上。
今天有 n n n位乘客上车。数组 a a a按时间顺序记录了他们的座位号。也就是说, a 1 a_1 a1包含了第一位乘客的座位号, a 2 a_2 a2-第二位乘客的座位号,以此类推。
你知道数组 a a a的内容。确定是否所有乘客都遵循了建议。
例如,如果 n = 5 n=5 n=5和 a a a=[ 5 , 4 , 2 , 1 , 3 5,4,2,1,3 5,4,2,1,3],那么建议就没有被遵守,因为第 3 3 3个乘客坐在了座位号为 2 2 2的座位上,而相邻的座位号为 1 1 1和 3 3 3的座位是空闲的。
分析:
按题意模拟 ,每次判断相邻位置是否有乘客,如果都没有,那么返回false
, 否则置
a
[
x
]
=
1
a[x]=1
a[x]=1, 继续判断下一个。
代码:
#include<bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n + 2, 0);
bool tag = true;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (i == 1) {
a[x] = 1;
continue;
} else {
if (a[x - 1] == 1 || a[x + 1] == 1) {
a[x] = 1;
continue;
} else {
tag = false;
}
}
}
if (tag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
C.Numeric String Template(遍历)
题意:
克里斯蒂娜有一个由 n n n个整数组成的数组 a a a,称为模板。她还有 m m m个字符串,每个字符串都只由小写拉丁字母组成。这些字符串的编号从 1 1 1到 m m m。她想检查哪些字符串与模板匹配。
如果同时满足以下所有条件,则认为字符串 s s s与模板匹配:
- 字符串 s s s的长度等于数组 a a a中的元素个数。
- 来自 a a a的相同数字对应于来自 s s s的相同符号。因此,如果是 a i = a j a_i=a_j ai=aj,那么 s i = s j s_i=s_j si=sj( 1 ≤ i , j ≤ n 1\le i,j\le n 1≤i,j≤n)。
- 来自 s s s的相同符号对应于来自 a a a的相同数字。因此,如果是 s i = s j s_i=s_j si=sj,那么 a i = a j a_i=a_j ai=aj( 1 ≤ i , j ≤ n 1\le i,j\le n 1≤i,j≤n)。
换句话说,字符串中的字符与数组中的元素必须一一对应。
例如,如果 a a a=[ 3 , 5 , 2 , 1 , 3 3,5,2,1,3 3,5,2,1,3],那么字符串"abfda"与模板匹配,而字符串"afbfa"则不匹配,因为字符"f"同时对应数字 1 1 1和 5 5 5。
分析:
按顺序遍历字符串,用两个map
给字母和数字建立起一一映射关系,然后进行判断即可。
代码:
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
const LL N = 10000005;
LL a[N];
void solve() {
LL n;
cin >> n;
for (LL i = 0; i < n; i++) {
cin >> a[i];
}
LL m;
cin >> m;
while (m--) {
map<LL, char> q1;
map<char, LL> q2;
map<LL, bool> vis1;
map<char, bool> vis2;
string text;
cin >> text;
if (text.length() != n) {
cout << "NO" << endl;
continue;
}
bool ok = 1;
for (LL i = 0; i < n; i++) {
if (vis1[a[i]]) {
if (text[i] != q1[a[i]]) {
cout << "NO" << endl;
ok = 0;
break;
}
}
if (vis2[text[i]]) {
if (a[i] != q2[text[i]]) {
cout << "NO" << endl;
ok = 0;
break;
}
}
vis1[a[i]] = 1;
vis2[text[i]] = 1;
q1[a[i]] = text[i];
q2[text[i]] = a[i];
}
if (ok) {
cout << "YES" << endl;
}
}
}
int main() {
LL T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
D.Right Left Wrong(双指针)
题意:
弗拉德发现了一个由 n n n个单元格组成的长条,从左到右的编号为 1 1 1到 n n n。在第 i i i个单元格中,有一个正整数 a i a_i ai和一个字母 s i s_i si,其中所有的 s i s_i si不是"L"就是"R"。
弗拉德邀请您尝试进行任意数量(可能为零)的运算,以获得尽可能多的分数。
在一次操作中,您可以选择两个索引 l l l和 r r r( 1 ≤ l < r ≤ n 1\le l\lt r\le n 1≤l<r≤n)。使得 s l s_l sl='L’和 s r s_r sr=‘R’,然后执行以下操作:
- 为当前积分加上 a l + a l + 1 + ⋯ + a r − 1 + a r a_l+a_{l+1}+\dots+a_{r-1}+a_r al+al+1+⋯+ar−1+ar分;
- 将所有 l ≤ i ≤ r l\le i\le r l≤i≤r的 s i s_i si替换为’.',这意味着您不能再选择这些索引。
例如,请考虑以下长条:
3 3 3 | 5 5 5 | 1 1 1 | 4 4 4 | 3 3 3 | 2 2 2 |
---|---|---|---|---|---|
l | r | l | l | r | l |
你可以先选择 l = 1 l=1 l=1、 r = 2 r=2 r=2,然后在分数上加上 3 + 5 = 8 3+5=8 3+5=8。
3 3 3 | 5 5 5 | 1 1 1 | 4 4 4 | 3 3 3 | 2 2 2 |
---|---|---|---|---|---|
. | . | L | L | L | R |
然后选择 l = 3 l=3 l=3、 r = 6 r=6 r=6,再加上 1 + 4 + 3 + 2 = 10 1+4+3+2=10 1+4+3+2=10。
3 3 3 | 5 5 5 | 1 1 1 | 4 4 4 | 3 3 3 | 2 2 2 |
---|---|---|---|---|---|
. | . | . | . | . | . |
因此,不可能再进行其他操作,最终得分是 18 18 18。
最大得分是多少?
分析:
首先,由于 a [ i ] > = 1 a[i]>=1 a[i]>=1 ,所以我们总是希望尽可能多的取数。
我们希望每一个数字被取的次数尽可能多,那么最优的方案就是找到最左边的 L L L和最右边的 R R R,之后,再找到剩余的项中,最左边的 L L L和最右边的 R R R,以此类推,使用双指针往里缩,前缀和优化即可。
代码:
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
const LL N = 1e6 + 7;
LL a[N];
void solve() {
LL n;
cin >> n;
for (LL i = 1; i <= n; i++)
cin >> a[i];
for (LL i = 1; i <= n; i++)
a[i] += a[i - 1];
string s;
cin >> s;
s = ' ' + s;
LL l = 1, r = n;
LL ans = 0;
while (true) {
while (s[l] != 'L' && l <= n) l++;
while (s[r] != 'R' && r >= 1) r--;
if (l <= r)
ans += (a[r] - a[l - 1]);
else
break;
l++, r--;
}
cout << ans << endl;
}
int main() {
LL T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
E.Photoshoot for Gorillas(贪心)
题意:
你非常喜欢大猩猩,所以决定为它们组织一次摄影活动。大猩猩生活在丛林中。丛林是由 n n n行和 m m m列组成的网格。 w w w只大猩猩同意参加拍摄,索引为 i i i( 1 ≤ i ≤ w 1\le i\le w 1≤i≤w)的大猩猩的高度为 a i a_i ai。您希望将所有大猩猩放入网格单元格中,使每个单元格中的大猩猩数量不超过一只。
这个排列的奇观等于边长为 k k k的所有子方格的奇观之和。
一个子方格的奇观等于该子方格中大猩猩的高度之和。
从所有合适的排列中,选择一个最大的排列。
分析:
本题考虑贪心,观察样例解释可以发现,中心的格子会被多次记录,所以我们只需要把大值从中心向外填充即可,因为用二维平面填充比较困难,所以我们就可以转化为记录每个格子被重复记录的个数,用优先队列将其储存,每次取队头与最高的猩猩乘积得值最后相加即可。
代码:
#include<bits/stdc++.h>
typedef long long LL;
using namespace std;
void solve() {
int n, m, k, w;
cin >> n >> m >> k >> w;
vector<int> a(w);
for (int i = 0; i < w; i++) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
vector<vector<int>> grid(n, vector<int>(m, 0));
for (int i = 0; i <= n - k; i++) {
for (int j = 0; j <= m - k; j++) {
for (int x = i; x < i + k; x++) {
for (int y = j; y < j + k; y++) {
grid[x][y]++;
}
}
}
}
priority_queue<int> pq;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] > 0) {
pq.push(grid[i][j]);
}
}
}
LL res = 0;
for (int i = 0; i < w && !pq.empty(); i++) {
int top = pq.top();
pq.pop();
res += static_cast<LL>(top) * a[i];
}
cout << res << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
F.Color Rows and Columns(动态规划)
题意:
你们有 n n n个矩形,其中 i i i个矩形的宽度为 a i a_i ai,高度为 b i b_i bi。
您可以无限次地执行以下操作:选择一个矩形和其中的一个单元格,然后为其着色。
每次为任意一行或任意一列完全着色,你都可以获得 1 1 1分。你的任务是用尽可能少的操作获得至少 k k k分。
假设有一个长方形,宽为 6 6 6,高为 3 3 3。您可以通过对任意 4 4 4列中的所有单元格着色,从而执行 12 12 12次操作,得到 4 4 4分。
分析:
本题考虑动态规划,令 d p [ i ] dp[i] dp[i]代表获取 i i i分所需要的最少次数。
对于每一个矩阵, 获取得到分数与相应最少操作次数存放在 m e me me数组中。先枚举 j j j, 再枚举这个矩阵的得分 p p p,然后更新。
可得动态转移方程: d p [ j + p ] = m i n ( d p [ j + p ] , d p [ j ] + m e [ p ] ) dp[j+p]=min(dp[j+p],dp[j]+me[p]) dp[j+p]=min(dp[j+p],dp[j]+me[p])
代码:
#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
void solve() {
int n, k;
cin >> n >> k;
vector<int> dp(k + 1, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
vector<int> me(k + 1, INF);
me[0] = 0;
int cnt = 0;
int cost = 0;
while (cnt < k && (a > 0 || b > 0)) {
if (a < b)
swap(a, b);
cnt += 1;
cost += b;
a -= 1;
me[cnt] = cost;
}
for (int j = k - 1; j >= 0; j--) {
for (int p = 1; p <= k - j; p++) {
dp[j + p] = min(dp[j + p], dp[j] + me[p]);
}
}
}
cout << (dp[k] == INF ? -1 : dp[k]) << endl;
}
int main() {
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
赛后交流
在比赛结束后,会在交流群中给出比赛题解,同学们可以在赛后查看题解进行补题。
群号: 704572101,赛后大家可以一起交流做题思路,分享做题技巧,欢迎大家的加入。