蔚来杯2022牛客暑期多校训练营6 ABGJM
A
题解
知识点：数学，构造。
题目要求构造一个长为 \(m\) 的序列 \(c\) ，\(m\) 自选，使得 \(c\) 的无限循环序列 \(b\) 中任意连续 \(a_i\) 个数中都存在数 \(i\) 。因此，容易想到从起点 \(pos_i\) 开始每隔 \(a_i\) 个数就填一次 \(i\) ，即在位置 \((pos_i + ka_i) \mod m , 0\leq k < \frac{m}{a_i}\) ，由此确定了构造的基本方法是填数。
但显然，直接挨个填数很可能会使得某个数的某个落点已经被其他数占据了。比如当 \(a = [5,4]\) 时，考虑构造 \(m=5\) 的序列：先填 \(1\) 得到 \([1,0,0,0,0]\) ，再填 \(2\) 得到 \([1,2,0,0,0]\) ，发现下一个位置是 \(c[0]\) ，已经有数字了。然而事实上，我们不容易在较小的时间复杂度内得到一个合适的起点，使得这个数的落点不会被其他数占据。因此，考虑调整 \(a_i\) ，使得我们可以容易避免落点重合的情况。
证明1
显然，我们只能缩小 \(a_i\) 使得，因为缩小后的 \(a_i\) 满足时原来的 \(a_i\) 一定满足，而放大不一定。
注意到，对于任意两个数 \(a_i\) 与 \(a_j\)， 当 \(a_j = da_i,d\geq1\) ，若 \(\exist k,m\) ，使得 \(pos_i + ka_i = pos_j +ma_j\) ，则有 \(pos_j = pos_i + ka_i - ma_j\) ，于是对于 \(\forall m'\)，都有 \(pos_j + m'a_j = pos_i + ka_i + (m'-m)a_j = pos_i + [k+(m'-m)d]a_i\) ，即处处重合。
因此，当 \(a_j = da_i\) ，只要一处不重合，则所有落点都不重合。为了方便，将 \(a_i\) 缩小成小于等于它的最大的 \(2\) 的幂 \(a'_i\)。
但仅仅是这样只能保证两两不重合，还无法保证全都不重合。比如当 \(a = [8,8,8,8,4]\) ，考虑 \(m = 8\) ，按顺序填，填到 \(5\) 时会发现 \([1,2,3,4,5,0,0,0]\) ，下一个位置是 \(c[0]\) ，还是被占据了。因此考虑改变填数顺序，使得后一个填的数不会被前面所有的数的位置影响。
证明2
从大到小的就是上述情况，不可行。
考虑从小到大，每次在第一个空位开始填。
由于每次都是从第一个空位填，所以不允许某个 \(a_i'\) 前面填了大于等于 \(a_i'\) 个位置，否则必然会循环回来落到开头被占据的位置，如上述情况。只要我们证明，对于任意一个 \(a_i’\)，其前方已经填的位置数 \(x < a_i'\) ，即可。
由于 \(a_i' > \dfrac{a_i}{2}\) ，又条件告诉我们有 \(\sum \frac{1}{a_i} \leq \frac12\) ，那么现在有 $\sum \frac{1}{a_i'} < \sum \frac{2}{a_i} \leq 1 $ 。
当填到 \(a_i' = 2^k\) 时，我们尝试构造 \(a_{1\cdots i-1}' \leq 2^k\) ，使得从 \(0\) 开始连续占用最多的位置。注意到，如果 \(a_j' = 2^ma_i',m\geq 1\)，则使用 \(a_i'\) 等效于使用了 \(2^m\) 个 \(a_j'\) ，且总和 \(2^m \frac{1}{a_j'} = \frac{1}{a_i'}\) 也是等价的 ，所以我们按这个方法，无论怎么取，最优结果都是一样的。因此在 \(\sum a_i' \leq 1 \Rightarrow \frac{1}{a_1'} + \cdots + \frac{1}{a_{i-1}'} \leq 1-\frac{1}{2^k}\) 下，为了方便，我们可以优先用小的 \(a_i\) 构造，快速缩小可行范围。
显然，我们只能构造 \(a = [2,4,8,\cdots,2^k]\) ，其倒数总和刚好是 \(1-\frac{1}{2^k}\) ，而连续占用位置是 \(2^k-1\) 个。
于是我们证明了这个结论。
到这里其实最难的两个证明已经结束了。接下来我们思考一下 \(m\) 到底取多少合适。
证明3
长度 \(m\) 时占位为 \(\sum \lceil \frac{m}{a_i'} \rceil\) ，因为每个 \(a_i'\) 对应的 \(i\) 至少出现一次，可得 \(m \geq max(a)\)。
令 \(m = max(a)\) ，带入得 \(\sum \lceil \frac{m}{a_i'} \rceil = \sum \frac{m}{a_i'} \leq m\) ，因此 \(m = max(a)\) 是最小长度。
由于可能多出空位，但是可以随便填，所以全填 \(1\) 。
到此这道构造题就完全结束了。
时间复杂度 \(O(n\log n + max(a))\)
空间复杂度 \(O(n+max(a))\)
代码
#include <bits/stdc++.h>
using namespace std;
struct node {
int val;
int id;
}a[100007];
int c[1000007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1;i <= n;i++) {
cin >> a[i].val;
a[i].id = i;
int tmp = 1 << 30;
while (tmp > a[i].val) tmp >>= 1;
a[i].val = tmp;
}///使用2的幂，证明1
sort(a + 1, a + n + 1, [&](node a, node b) {
return a.val < b.val;
});///从小到大，证明2
int m = a[n].val;///c的长度，证明3
for (int i = 1, pos = 0;i <= n;i++) {
for (int j = pos;j < m;j += a[i].val) c[j] = a[i].id;///方法是填数
while (c[pos]) pos++;
}
cout << m << '\n';
for (int i = 0;i < m;i++) cout << max(1, c[i]) << ' ';///可能多出来空位随便填
cout << '\n';
return 0;
}
B
题解
知识点：枚举，前缀和，差分，树。
考虑树上前缀和与差分。维护当前递归的一条树链的深度到节点编号的映射数组 \(depL\) 即可差分，最后递归求前缀和。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2000007];
int d[2000007];
int dep[2000007], depL[2000007];///节点深度，一条链上深度对应节点
int sum[2000007];///树上差分
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
depL[dep[u]] = u;
sum[u]++;
sum[depL[max(0, dep[u] - d[u] - 1)]]--;
for (auto v : g[u]) {
if (v == fa) continue;
dfs(v, u);
}
}
void cal(int u, int fa) {
for (auto v : g[u]) {
if (v == fa) continue;
cal(v, u);
sum[u] += sum[v];
}
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1;i < n;i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1;i <= n;i++) cin >> d[i];
dfs(1, 0);
cal(1, 0);
for (int i = 1;i <= n;i++) cout << sum[i] << ' ';
cout << '\n';
return 0;
}
G
题解
知识点：模拟。
签到题。直接打表也行，模拟也行。
时间复杂度 \(O(n^2)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1;i <= 13 * n + 19;i++) cout << '*';
cout << '\n';
for (int i = 1;i <= n;i++) {
cout << "*";
for (int j = 2;j <= 13 * n + 18;j++)
cout << ".";
cout << "*";
cout << '\n';
}
for (int i = 1;i <= 2 * n + 3;i++) {
cout << "*";
for (int j = 1;j <= n + 1;j++) cout << ".";
for (int j = 1;j <= 2 * n + 3;j++) {
if (i == 1 || i == 2 * n + 3) {
if (j == 1 || j == 2 * n + 3) cout << "@";
else cout << ".";
}
else {
if (j == 1 || j == 2 * n + 3 || j == i) cout << "@";
else cout << ".";
}
}
for (int j = 1;j <= n + 1;j++) cout << ".";
for (int j = 1;j <= 2 * n + 3;j++) {
if (i == 1 || i == n + 2) cout << "@";
else {
if (j == 1) cout << "@";
else cout << ".";
}
}
for (int j = 1;j <= n + 1;j++) cout << ".";
for (int j = 1;j <= 2 * n + 3;j++) {
if (i == 2 * n + 3) cout << "@";
else {
if (j == 1) cout << "@";
else cout << ".";
}
}
for (int j = 1;j <= n + 1;j++) cout << ".";
for (int j = 1;j <= 2 * n + 3;j++) {
if (i == 1 || i == n + 2 || i == 2 * n + 3) cout << "@";
else if (1 < i && i < n + 2) {
if (j == 1) cout << "@";
else cout << ".";
}
else if (n + 2 < i && i < 2 * n + 3) {
if (j == 2 * n + 3) cout << "@";
else cout << ".";
}
}
for (int j = 1;j <= n + 1;j++) cout << ".";
cout << "*";
cout << '\n';
}
for (int i = 1;i <= n;i++) {
cout << "*";
for (int j = 2;j <= 13 * n + 18;j++)
cout << ".";
cout << "*";
cout << '\n';
}
for (int i = 1;i <= 13 * n + 19;i++) cout << '*';
cout << '\n';
return 0;
}
J
题解
知识点：思维，数学。
A不能变，B只有A-B与B两个值，于是C的变换方法只有形如交替的A-B与B，而最终C的符号取决于偶数次变换还是奇数次。公式为：
这里的 \(k\) 取负时的意义简单理解是交换了变换顺序，比如 \([A-B,B] \rightarrow [B,A]\) 。只要找到整数 \(k\) 满足等式即可，注意 \(2B-A = 0\) 时需要特判。
时间复杂度 \(O(1)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool solve() {
int a, b, c, x;
cin >> a >> b >> c >> x;
if (2 * b - a == 0) {
if (x - c == 0 || x + c - b == 0) cout << "Yes" << '\n';
else return false;
}
else if ((x - c) % (2 * b - a) == 0 || (x + c - b) % (a - 2 * b) == 0) cout << "Yes" << '\n';
else return false;
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << "No" << '\n';
}
return 0;
}
M
题解
知识点：线性dp，博弈论。
通过转移局面情况到起点，然后判断起点是否到达目标状态。
其中由于走法是固定向下或者向右，所以可以通过横纵坐标之和的奇偶性来决定当前是谁的回合。
对于A而言，两种走法有一种能得到目标状态就转移；对于B而言，两种走法有一种得不到目标状态就转移。
具体看代码注释qwq。
时间复杂度 \(O(nm)\)
空间复杂度 \(O(nm)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
char dt[507][507];
int dp[507][507];
///三种局面是可以独立考虑的，分别看作能否一定走到A、B、(n,m)处状态
///用三位二进制分别表示(i, j)处A是否一定能走到A、B、(n, m)处状态
///1表示一定能走到，0表示不一定能走到（包括一定不）
///已知A处001，终点处为010,B处100
bool solve() {
int n, m;
cin >> n >> m;
for (int i = 1;i <= n;i++)
for (int j = 1;j <= m;j++)
cin >> dt[i][j];
for (int i = n;i >= 1;i--) {
for (int j = m;j >= 1;j--) {
if (dt[i][j] == 'A') { dp[i][j] = 1;continue; }
if (dt[i][j] == 'B') { dp[i][j] = 4;continue; }
if (i == n && j == m) { dp[i][j] = 2;continue; }
if (i == n) dp[i][j] = dp[i][j + 1];
else if (j == m) dp[i][j] = dp[i + 1][j];///无路可走的两种直接传递
else if ((i + j) & 1) dp[i][j] = dp[i + 1][j] & dp[i][j + 1];///可以通过坐标之和奇偶性得知是谁的回合，因为只能往下或者往右走，每轮都只会加一
else dp[i][j] = dp[i + 1][j] | dp[i][j + 1];///每种局面有0则B一定走0,有1则A一定走1
}
}
if (dp[1][1] & 1) cout << "yes" << ' ';
else cout << "no" << ' ';
if (dp[1][1] & 2) cout << "yes" << ' ';
else cout << "no" << ' ';
if (dp[1][1] & 4) cout << "yes" << ' ';
else cout << "no" << ' ';
cout << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/16560477.html
