Educational Codeforces Round 136 (Rated for Div. 2) A-E
A
题解
知识点：模拟。
所有点都跑一遍即可。
另外可以不模拟， \(\geq 2*2\) 的情况都可以摆在 \((2,2)\) 这个点，其他摆在 \((1,1)\) 。
时间复杂度 \(O(nm)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int dir[8][2] = { {-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1} };
bool solve() {
int n, m;
cin >> n >> m;
int x = n, y = m;
for (int i = 1;i <= n;i++) {
for (int j = 1;j <= m;j++) {
bool ok = false;
for (int k = 0;k < 8;k++) {
int xx = i + dir[k][0];
int yy = j + dir[k][1];
ok |= xx >= 1 && xx <= n && yy >= 1 && yy <= m;
}
if (!ok) {
x = i;
y = j;
break;
}
}
}
cout << x << ' ' << y << '\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;
}
B
题解
知识点：贪心。
显然，根据 \(d_i\) 可以得到 \(a_i = a_{i-1} \pm d_i\) ，但 \(a_i \geq 0\) ，因此如果 \(d_i \neq 0\) 且 \(a_{i-1} - d_i \geq 0\) 时说明有两个合法 \(a_i\) 输出 \(-1\) ，否则继续构造。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int d[107];
bool solve() {
int n;
cin >> n;
for (int i = 1;i <= n;i++) cin >> d[i];
for (int i = 2;i <= n;i++) {
if (d[i] && d[i - 1] - d[i] >= 0) return false;
d[i] += d[i - 1];
}
for (int i = 1;i <= n;i++) cout << d[i] << ' ';
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;
}
C
题解
知识点：排列组合，构造，线性dp。
总局面一共 \(C_{n}^{\frac{n}{2}}\) 种。
注意到平局只有 \(1\) 种情况，即每次最大的牌都在对方手里，而自己手里有次大的牌，如此就能构造出平局的局面了。比如在 \(n = 8\) 时，平局为 \(A\) 拥有 \(7632\) ，\(B\) 有 \(8541\) 。因此只要求出 \(A\) 赢局面，就能得到 \(B\) 赢局面。
如果 \(A\) 的局面比其平局局面的从大到小的某一回合牌更大（前面回合的牌和平局一样，后面的牌随意分配），那么 \(A\) 赢。如 \(A\) 有 \(7641\) ，\(76\) 一样但 \(4\) 比 \(3\) 大，因此 \(A\) 赢。对 \(B\) 也是同理的。
再者，我们注意到，局面情况是可以递推的。如 \(n=8\) 时第一回合结束就来到 \(n=6\) 的情况，不过 \(B\) 成先手了。
因此我们对 \(n = i\) 的局面，可以先求出第一回合的情况，再用 \(n=i-2\) 的结果即可。
显然第一回合 \(A\) 赢的情况，只有牌是最大 \(i\) 的时候，此时剩下的牌可以随便选，一共有 \(C_{i-1}^{\frac{i}{2}-1}\) 种，接下来的情况和 \(n=i-2\) 时 \(B\) 赢等价。
我们定义 \(ansA[i]\) 为 \(n = i\) 时 \(A\) 赢的局面数，\(ansB[i]\) 为 \(n=i\) 时 \(B\) 赢的局面数。 有递推关系：
时间复杂度 \(O(60^2)\)
空间复杂度 \(O(60^2)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int mod = 998244353;
int ansA[67], ansB[67];
int C[67][67];
void init(int n = 60) {
for (int i = 0;i <= n;i++) {
for (int j = 0;j <= i;j++) {
if (j == 0 || i == j) C[i][j] = 1;
else C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
}
void get(int n = 60) {
ansA[2] = 1;
ansB[2] = 0;
for (int i = 4;i <= n;i += 2) {
ansA[i] = (C[i - 1][i / 2 - 1] + ansB[i - 2]) % mod;
ansB[i] = (C[i][i / 2] - ansA[i] - 1 + mod) % mod;
}
}
bool solve() {
int n;
cin >> n;
cout << ansA[n] << ' ' << ansB[n] << ' ' << 1 << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
init();
get();
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
D
题解
知识点：二分，树形dp。
这道题答案具有单调性，因此可以二分答案 \(mid\) 。
设 \(dp[u]\) 为节点 \(u\) 希望的高度。自底向上处理，把叶子节点希望高度设为 \(mid\) 。父节点的希望高度为所有子节点希望高度最小值减 \(1\) 。
当 \(dp[u] = 1\) 时，除了节点 \(1\) 和父节点是 \(1\) 的节点，都属于需要操作的节点，因此操作次数加 \(1\) 。但要注意，操作过的节点希望高度需要设为 \(mid+1\) ，这个子节点已经与原来的父节点分离了，其希望高度不能影响到原来的父节点，所以设为父节点可能的希望高度最大值加 \(1\) 。
最后判断一下操作次数有没有超过 \(k\) 来进行二分即可。
时间复杂度 \(O(n \log n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
vector<int> g[200007];
int dp[200007];
int n, k;
int mid, cnt;
void dfs(int u, int fa) {
dp[u] = mid;
for (auto v : g[u]) {
if (v == fa) continue;
dfs(v, u);
dp[u] = min(dp[u], dp[v] - 1);
}
if (dp[u] == 1 && fa != 1 && u != 1) {
cnt++;
dp[u] = mid + 1;
}
}
bool check(int mid) {
cnt = 0;
dfs(1, 0);
return cnt <= k;
}
bool solve() {
cin >> n >> k;
for (int i = 1;i <= n;i++) g[i].clear();
for (int i = 2;i <= n;i++) {
int u;
cin >> u;
g[i].push_back(u);
g[u].push_back(i);
}
int l = 1, r = n - 1;
while (l <= r) {
mid = l + r >> 1;
if (check(mid)) r = mid - 1;
else l = mid + 1;
}
cout << l << '\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;
}
E
题解
知识点：状压dp。
设 \(dp[i][j]\) 表示清理到第 \(i\) 列第 \(j\) 行格子且第 \(i-1\) 列及以前的格子也都清理时，机器人清理的最大格子数。
假设机器人走到了第 \(i\) 列第 \(j\) 行（接下来称为 \((i,j)\) ），接下来有两种走法：继续往右直走，换另一行往右直走。
-
第一种情况往右直走，此时我们需要手动保证 \((i,1-j)\) 没垃圾，但其影响不了机器人下一步行动，所以可以直接转移：
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + (s[j][i + 1] == '1')); -
第二种情况换行往右直走，但这种情况建立在 \((i,1-j)\) 有垃圾，否则机器人不会换行。此时我们需要手动保证 \((i+1,j)\) 没垃圾，但不能直接转移到 \((i+1,1-j)\) ，因为此时转移的状态是建立在 \((i+1,j)\) 一定没有垃圾的情况。但 \((i+1,1-j)\) 也有可能会从 \((i+1,j)\) 转移过来，这个转移是没有限制的。因此转移的前提都不同了，所以第二种转移具有后效性。解决方案是继续顺着走到 \((i+2,1-j)\)，既然 \((i+1,j)\) 在这种情况下保证没有垃圾了，不妨继续走到 \((i+2,1-j)\) ，此时是没有后效性的，转移方程为：
dp[min(i + 2, n)][j ^ 1] = max(dp[min(i + 2, n)][j ^ 1], dp[i][j] + 1 + (s[j ^ 1][i + 1] == '1') + (s[j ^ 1][i + 2] == '1'));
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
int dp[200007][2];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
string s[2];
cin >> s[0] >> s[1];
memset(dp, -0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 0;i < n;i++) {
for (int j = 0;j < 2;j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + (s[j][i + 1] == '1'));
if (s[j ^ 1][i] == '1')
dp[min(i + 2, n)][j ^ 1] = max(dp[min(i + 2, n)][j ^ 1], dp[i][j] + 1 + (s[j ^ 1][i + 1] == '1') + (s[j ^ 1][i + 2] == '1'));
}
}
cout << max(dp[n][0], dp[n][1]) << '\n';
return 0;
}
本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/16773075.html
