AtCoder Beginner Contest 430 ABCDEF 题目解析

A - Candy Cookie Law

题意

在高桥居住的 AtCoder 国家有一条奇怪的法律，即“如果一个人拥有的糖果数量 \(\ge A\)，那么他拥有的饼干数量就必须 \(\ge B\)”。

高桥拥有 \(C\) 颗糖果和 \(D\) 块饼干，请判断高桥是否违反了这条法律。

代码

void solve()
{int a, b, c, d;cin >> a >> b >> c >> d;if(c >= a && d < b)cout << "Yes";elsecout << "No";
}

---

B - Count Subgrid

题意

有一个 \(N \times N\) 的网格，第 \(i\) 行第 \(j\) 列的网格颜色用 \(S_{i, j}\) 描述。如果 \(S_{i,j}\) 是 #，表示其为黑色；如果是 .，表示其为白色。

问网格内部有多少种不同的大小为 \(M \times M\) 的子网格？

思路

一种比较简单的方法是，先枚举每个大小为 \(M \times M\) 的子网格，然后将子网格的每一行字符首尾拼在一起，形成一个长度为 \(M^2\) 的字符串，最后再结合 set 容器进行去重操作。

代码

int n, m;
char mp[15][15];void solve()
{cin >> n >> m;for(int i = 1; i <= n; i++)for(int j = 1; j <= n; j++)cin >> mp[i][j];set<string> st;for(int i = 1; i + m - 1 <= n; i++)for(int j = 1; j + m - 1 <= n; j++) // 枚举每个左上角 (i, j){string s = "";for(int x = i; x <= i + m - 1; x++)for(int y = j; y <= j + m - 1; y++)s += mp[x][y];st.insert(s);}cout << st.size();
}

---

C - Truck Driver

题意

在 AtCoder 国家有这样一条规定："一位卡车司机在驾驶至少 \(A\) 分钟之后，必须要休息至少 \(B\) 分钟"。

给你一个长度为 \(N\) 且仅由 a 和 b 组成的字符串 \(S\) 以及两个正整数 \(A\) 和 \(B\)。求满足以下所有条件的整数对 \((l,r)\) 的个数：

• \(1\leq l \leq r \leq N\)
• 在 \(S\) 的第 \(l\) 个字符到第 \(r\) 个字符所形成的子串中，a 的个数 \(\ge A\)。
• 在 \(S\) 的第 \(l\) 个字符到第 \(r\) 个字符所形成的子串中，b 的个数 \(\lt B\)。

思路

枚举每个位置作为答案的左端点 \(l\)，然后考虑如何快速求出有多少个右端点 \(r\) \((r \ge l)\) 满足剩余的两个条件。

可以先通过前缀和数组 \(PA, PB\) 预处理出字符串的每个前缀中的 a 和 b 的数量，可以发现这两个数组一定是单调非递减的。

对于条件二，要保证子串中 a 的个数 \(\ge A\)，那我们便可以借助 \(PA_r - PA_{l-1}\) 来快速求出区间 \([l, r]\) 内的 a 的数量，借助二分找到符合条件的最小位置 \(x_a\)。

对于条件三，要保证子串中 b 的个数 \(\lt B\)，那我们便可以借助 \(PB_r - PB_{l-1}\) 来快速求出区间 \([l, r]\) 内的 b 的数量，借助二分找到符合条件的最大位置 \(x_b\)。

明显 \([x_a, x_b]\) 区间内的每个位置都能作为右端点 \(r\)，与此时枚举的左端点 \(l\) 组合为一对整数对。

时间复杂度 \(O(N\log N)\)。

代码

int pa[300005], pb[300005];void solve()
{int n, a, b;cin >> n >> a >> b;for(int i = 1; i <= n; i++){char c;cin >> c;pa[i] = pa[i-1];pb[i] = pb[i-1];if(c == 'a')pa[i]++;elsepb[i]++;}long long ans = 0;for(int i = 1; i <= n; i++){// 找最小的 j 满足 pa[j] - pa[i-1] >= a// 即找第一个 >= a + pa[i-1] 的位置int xa = lower_bound(pa + 1, pa + n + 1, a + pa[i - 1]) - pa;// 找最大的 j 满足 pb[j] - pb[i-1] < b// 即找最后一个 < b + pb[i-1] 的位置// 也就是第一个 >= b + pb[i-1] 的位置的前一个位置int xb = lower_bound(pb + 1, pb + n + 1, b + pb[i - 1]) - pb - 1;if(xa <= xb)ans += xb - xa + 1;}cout << ans;
}

---

D - Neighbor Distance

题意

有一条数轴，最初编号为 \(0\) 的人独自站在坐标 \(0\) 处。

从现在起，编号分别为 \(1,2,\dots,N\) 的人将按顺序到达并站在数轴上，编号为 \(i\) 的人会站在坐标 \(X_i\) 处。保证 \(X_i \ge 1\) 并且 \(X_i\) 互不相同。

每当有一个人到达时，请回答以下问题：

• 假设目前有 \(r+1\) 人 \(0,1,\dots,r\) 站在数列上。
• 定义 \(d_i\) 表示第 \(i\) 个人与离他最近的一个人之间的距离。
  • 也就是 \(\displaystyle d_i = \min_{0 \le j \le r, j \neq i} \vert X_i - X_j \vert\) 。
• 求 \(d\) 的和并输出。
  • 即 \(\displaystyle \sum_{i=0}^r d_i\) 。

思路

当有一个人到达 \(X_i\) 位置时，明显他只会对他左侧与右侧已经到达且距离他最近的最多两个人的答案进行改变。

可以借助 STL 容器 set 辅助维护目前新来的这个人左右两侧是否存在其他已经到达的人，借助容器内的二分进行实现。由于每个人坐标均不同，还可以借助 map 容器建立“坐标 -> 编号”的映射，便于根据坐标找到对应的人。

当然这一步也可以自己构造一个结构体（或使用 pair 容器），把坐标和编号绑定到一起放进 set 里。

找到可能受影响的左右两个人之后，根据其位置关系更新它的 \(d_x\)，并同时更新最终总和即可。

为了方便代码实现，以及防止出现越界情况，可以在坐标范围 \([1, 10^9]\) 的左右两侧再分别放一个无效位置。题目已经给定了一个位置 \(0\)，但该位置是有用的，所以我们可以再造两个位置，例如 \(-1\) 以及 \(10^9+1\)。

时间复杂度 \(O(N\log N)\)。

代码

int n;
set<int> st; // 存储已经存在的每个人的位置
map<int, int> mp; // 根据位置查编号
int d[500005]; // d[i] 表示当前 i 这个人的答案
ll ans = 0; // 当前答案总和// 更新 set 内部迭代器 it 所对应的人的答案
void cal(set<int>::iterator it)
{int pos = *it; // 获得对应坐标int id = mp[pos]; // 获得这个人的编号if(id == -1) // 无效位置，不更新return;ans -= d[id]; // 去掉旧答案d[id] = 2e9; // 初始化为最大值// 查看右侧是否存在已出现的数字it++;int posr = *it;int idr = mp[posr];if(idr != -1) // 右侧不是无效位置，更新d[id] = min(d[id], posr - pos);// 查看左侧是否存在已出现的数字it--; it--;int posl = *it;int idl = mp[posl];if(idl != -1) // 左侧不是无效位置，更新d[id] = min(d[id], pos - posl);ans += d[id]; // 加上新答案
}void solve()
{cin >> n;st.insert(-1);st.insert(0);st.insert(1000000001);mp[-1] = mp[1000000001] = -1; // 无效位置，编号记作 -1mp[0] = 0;for(int i = 1; i <= n; i++){int x;cin >> x;auto it = st.insert(x).first; // 获取插入后的指针，也可以插入完成后用 find 获得mp[x] = i;cal(it); // 更新当前新来的人的答案it++;cal(it); // 更新右侧的答案it--; it--;cal(it); // 更新左侧的答案cout << ans << "\n";}
}

---

E - Shift String

题意

给定两个等长的仅包含 a 和 b 的字符串 \(A\) 和 \(B\)。

你可以对字符串 \(A\) 执行零次或多次以下操作：

• 将字符串的第一个字母移动到字符串末尾。

请找出至少需要多少次操作，可以使得 \(A\) 和 \(B\) 两个字符串完全相同，或判断不可能实现。

思路

循环操作，不如一开始把原本的字符串 \(A\) 重复一次拼在自己的后面，形成一个长度为原本两倍的字符串 \(A\)。这样可以保证第 \(i\) 个字符与第 \(i+n\) 个字符相同（\(i \le n\)，其中 \(n\) 表示字符串原本的长度）。

这样，如果操作一次也不执行，那么我们判断的就是 \(A_{[1, n]}\) 是否与字符串 \(B\) 相同。

如果操作执行一次，判断的就是 \(A_{[2, n+1]}\) 是否与字符串 \(B\) 相同。

那么如果操作执行 \(k\) 次，判断的就是 \(A_{[k+1, n+k]}\) 是否与字符串 \(B\) 相同。

只需要借助字符串匹配相关的算法，找 \(A\) 字符串从哪个位置开始的长度为 \(n\) 的子串与模式串 \(B\) 相匹配即可。

以下代码借助 KMP 算法实现，时间复杂度 \(O(|A|+|B|)\)。

代码

#include<bits/stdc++.h>
using namespace std;int n, m;
string s, t;
int Next[1000005];void getNext()
{Next[1] = 0;int j = 0;for(int i = 2; i <= m; i++){while(j != 0 && t[i] != t[j + 1])j = Next[j];if(t[i] == t[j + 1])j++;Next[i] = j;}
}int KMP()
{int j = 0;for(int i = 1; i <= n; i++){while(j != 0 && s[i] != t[j + 1])j = Next[j];if(s[i] == t[j + 1])j++;if(j == m)return i - m; // 起始位置 i-m+1，操作次数为 i-m}return -1;
}void solve()
{cin >> s >> t;n = m = s.size();n = n * 2;s = " " + s + s; // 复制一份，前导占位t = " " + t;getNext();cout << KMP() << "\n";
}int main()
{int T;cin >> T;while(T--)solve();return 0;
}

---

F - Back and Forth Filling

题意

给定一个整数 \(N\) 以及一个长度为 \(N-1\) 且仅由 L 和 R 组成的字符串 \(S\)。

有 \(N\) 个单元格排成一排，你需要往每个单元格内填入一个整数，并满足以下条件：

• \(1 \sim N\) 内的每个整数均只会出现一次。
• 当 \(S\) 的第 \(i\) 个字符为 L，那么数字 \(i+1\) 会写在 \(i\) 的左侧的某个单元格内。
• 当 \(S\) 的第 \(i\) 个字符为 R，那么数字 \(i+1\) 会写在 \(i\) 的右侧的某个单元格内。

定义 \(C_i\) 表示有多少种整数可以写在左数第 \(i\) 个单元格内。

输出 \(C_1, C_2, \dots, C_N\)。

思路

可以从每种数字可以放置的位置出发来考虑问题。对于数字 \(i\)，考虑有哪些位置是其不可能出现的。

例如，对于字符串 $S = $LLRRRLLLLLRR：

• 考虑数字 \(3\)，在其左侧发现 \(S_{1 \sim 2}\) 均为字符 L，说明 \(3, 2, 1\) 必须按照该顺序放置在单元格内；在其右侧发现 \(S_{3 \sim 5}\) 均为i字符 R，说明数字 \(3, 4, 5, 6\) 必须按照该顺序放置在单元格内。
  • 那么 \(3\) 这个数字的右侧就一定会出现 \(2 + 3 = 5\) 个固定的数字，\(3\) 一定不会出现在右侧 \(5\) 个位置内。
• 考虑数字 \(6\)，在其左侧发现 \(S_{3 \sim 5}\) 均为字符 R，说明数字 \(3,4,5,6\) 必须按照该顺序放置在单元格内；在其右侧发现 \(S_{6 \sim 10}\) 均为字符 L，说明数字 \(11,10,9,8,7,6\) 必须按照该顺序放置在单元格内。
  • 那么 \(6\) 这个数字的左侧就一定会出现 \(5+4 = 9\) 个固定的数字，\(6\) 一定不会出现在左侧 \(9\) 个位置内。

可以发现，对于数字 \(i\) 而言，在 \(S\) 中从 \(i-1\) 位置开始往前连续的 R 字符数量以及从 \(i\) 位置开始往后连续的 L 字符数量就代表着必须放在数字 \(i\) 之前的数字数量，记作 \(x\)；在 \(S\) 中从 \(i-1\) 位置开始往前连续的 L 字符数量以及从 \(i\) 位置开始往后连续的 R 字符数量就代表着必须放在数字 \(i\) 之后的数字数量，记作 \(y\)。

那么区间 \([1, x]\) 以及区间 \([N-y+1, N]\) 都不可能放置数字 \(i\)，而可能出现数字 \(i\) 的区间也就是 \([x+1, N-y]\)。

对于每种数字，计算出其可能出现的区间后，输出每个位置被多少个区间包含，就代表着每个位置可能出现的数字数量。这一步可以简单采取差分数组实现。

单组数据时间复杂度 \(O(N)\)。

代码

#include<bits/stdc++.h>
using namespace std;int n;
string s;
int LL[300005], LR[300005], RL[300005], RR[300005];
// LL[i] LR[i] 表示从 i 开始 左侧连续 L 与 R 的数量
// RL[i] RR[i] 表示从 i 开始 右侧连续 L 与 R 的数量
int d[300005];void solve()
{cin >> n >> s;for(int i = 0; i <= n; i++)LL[i] = LR[i] = RL[i] = RR[i] = d[i] = 0;LL[0] = LR[0] = 0;for(int i = 1; i < n; i++){if(s[i - 1] == 'L')LL[i] = LL[i-1] + 1;elseLR[i] = LR[i-1] + 1;}RL[n] = RR[n] = 0;for(int i = n-1; i >= 1; i--){if(s[i - 1] == 'L')RL[i] = RL[i+1] + 1;elseRR[i] = RR[i+1] + 1;}for(int i = 1; i <= n; i++){int l = LR[i-1] + RL[i]; // 必须放在 i 左侧的数字数量int r = LL[i-1] + RR[i]; // 必须放在 i 右侧的数字数量d[1 + l]++;d[n + 1 - r]--;}for(int i = 1; i <= n; i++){d[i] += d[i-1];cout << d[i] << " ";}cout << "\n";
}int main()
{int T;cin >> T;while(T--)solve();return 0;
}