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\) 赢的局面数。 有递推关系：

\[\begin{aligned}
ansA[i] &= C_{i-1}^{\frac{i}{2}-1} + ansB[i-2]\\
ansB[i] &= C_{i}^{\frac{i}{2}} - ansA[i]-1
\end{aligned}
\]

时间复杂度 \(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)\) ），接下来有两种走法：继续往右直走，换另一行往右直走。

1. 第一种情况往右直走，此时我们需要手动保证 \((i,1-j)\) 没垃圾，但其影响不了机器人下一步行动，所以可以直接转移：

   dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + (s[j][i + 1] == '1'));
   

2. 第二种情况换行往右直走，但这种情况建立在 \((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;
}