比赛链接

A

题意

判断输入字符串与 \(\pi\) 的最长前缀匹配，不超过 \(30\) 位。

题解

知识点：模拟。

抄样例最后一个 \(30\) 都正确的，直接匹配。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

bool solve() {
    string s;
    cin >> s;
    string pi = "314159265358979323846264338327";
    int cnt = 0;
    for (int i = 0;i < s.size();i++) {
        if (s[i] != pi[i]) break;
        cnt++;
    }
    cout << cnt << '\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

题意

有 \(n\) 个骰子，数字 \(a_i \in [1,6]\) 的面朝上，现在给你骰子面朝上数字的总和 \(s\) ，以及去掉一个最大值的数字总和 \(r\) ，要求还原一个合法的 \(a_i\) 。

题解

知识点：枚举。

方法有很多，这里提供一种写起来很方便的。

先存一个最大值 \(mx = s - r\) ，依次给每个骰子分配点数 \(\min(mx,r)\) ，超过最大值直接给最大值。

但是为了保证不出现数字为 \(0\) 的情况，一开始先给所有骰子分配 \(1\) 点。

时间复杂度 \(O(n)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

bool solve() {
    int n, s, r;
    cin >> n >> s >> r;
    s -= n;
    r -= n - 1;
    int mx = s - r;
    cout << mx + 1 << ' ';
    for (int i = 2;i <= n;i++) {
        cout << min(r, mx) + 1 << ' ';
        r -= min(r, mx);
    }
    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

题意

对一个排列 \(p\) ，生成 \(n\) 个长为 \(n-1\) 新序列，第 \(i\) 个序列由 \(p\) 除了 \(p_i\) 的元素构成。

现在给你 \(p\) 生成的 \(n\) 个序列，但顺序是打乱的，要求还原一个合法的 \(p\) 。

题解

知识点：构造。

注意到 \(p_1\) 在 \(n\) 个序列的第一位会出现 \(n-1>1\) 次，而 \(p_2\) 只会出现 \(1\) 次 ，我们可以直接确定 \(p_1\) 。确定了 \(p_1\) ，我们找到没有 \(p_1\) 的一个序列，里面包含了 \(p_2,\cdots,p_n\) 直接输出即可。

时间复杂度 \(O(n^2)\)

空间复杂度 \(O(n^2)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int a[107][107];
int cnt[107];
bool solve() {
    int n;
    cin >> n;
    int fst = 0;
    vector<int> cnt(n + 1);
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= n - 1;j++) {
            cin >> a[i][j];
        }
        cnt[a[i][1]]++;
        if (cnt[a[i][1]] > 1) fst = a[i][1];
    }
    cout << fst << ' ';
    for (int i = 1;i <= n;i++) {
        if (a[i][1] != fst) {
            for (int j = 1;j <= n - 1;j++) cout << a[i][j] << " \n"[j == n - 1];
            break;
        }
    }
    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;
}

D

题意

给定一组数 \(a_i\) ，要求分出最少的分组，每组要求由连续上升的正整数构成。

对于连续上升，如 \(3,4,5,6\) 是连续上升的，而 \(1,3,4,5\) 不是，因为 \(1,3\) 中间跳过了 \(2\) 。

题解

知识点：贪心，枚举。

用 map 记录每个数的个数，从小到大遍历，设当前数字为 \(x\) ，上一次的数字为 \(pre\) ， \(cnt\) 表示数字的个数：

1. 如果 \(x > pre + 1\) ，我们就必须开新的 \(cnt_x\) 个分组，答案加 \(cnt_x\) 。
2. 如果 \(x = pre + 1\) ，则可以与上一次共用分组 \(cnt_x\) 个分组，但如果 \(cnt_x>cnt_{pre}\) ，那么多出来的部分要开新的分组，答案加 \(cnt_x-cnt_{pre}\) 。

时间复杂度 \(O(n \log n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

bool solve() {
    int n;
    cin >> n;
    map<int, int> mp;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        mp[x]++;
    }
    int ans = 0, pre = -1;
    for (auto [x, y] : mp) {
        if (x > pre + 1) ans += y;
        else ans += max(0, y - mp[pre]);
        pre = x;
    }
    cout << ans << '\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

题意

给定一个正整数 \(x \leq 2^{29}\) ，找到两个正整数 \(a,b \leq 2^{32}\) ，满足 \(\dfrac{a+b}{2} = a \oplus b = x\) 。

题解

知识点：位运算，构造。

我们分析 \(x\) 的第 \(i\) 位 \(x_i = 1\) ，则 \(a,b\) 相关位置的情况，假设 \(a,b\) 一开始都为 \(0\) ：

1. 首先满足 \(a \oplus b = x\) ，显然 \(a_i,b_i\) 必须是一个 \(1\) 和一个 \(0\) ，我们不妨设 \(a_i = 1,b_i = 0\) 。

2. 其次要满足 \(\dfrac{a+b}{2} = x\) ，根据1得到的 \(a_i+b_i = 1\) 不能满足除以 \(2\) 使得 \(x_i = 1\) ，考虑对附近其他位做调整。

   考虑调整 \(i+1\) 位，那么 \(a_{i+1},b_{i+1}\) 必须是一个 \(1\) 和一个 \(0\) ，我们不妨设 \(a_{i+1} = 1,b_{i+1} = 0\) 。但是，这样 \(x_{i+1}\) 必须等于 \(1\) ，假设 \(x_{i+1}=1\)，那么对于 \(i+1\) 位的第二步因为第 \(i\) 位锁定了，只能再往 \(i+2\) 位考虑，这是没有尽头的，所以这条路走不通。

   考虑调整 \(i-1\) 位，那么就必须 \(a_{i-1} = b_{i-1} = 1\) 才能产生一个进位使得 \(x_i = 1\) 。此时， \(x_{i-1}\) 必须等于 \(0\) ，假设 \(x_{i-1} = 0\) 就恰好满足所有需求。

综上，对于任何一个 \(x_i = 1\) 要满足 \(x_{i-1} = 0\) 时才有解（特别地， \(x_1 = 1\) 时无解）。满足有解条件后，我们考虑令 \(a_i = 1,b_i = 0\) ， \(a_{i-1} = b_{i-1} = 1\) ，即 \(a = 3 \cdot \dfrac{x}{2},b = \dfrac{x}{2}\) 。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

bool solve() {
    int x;
    cin >> x;
    int y = x >> 1;
    if ((x & 1) || (x & y)) return false;
    else cout << (x | y) << ' ' << 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;
}

F

题意

题解

方法一

知识点：根号分治，bfs，贪心。

做法很简单，每加入一个黑点就bfs一遍附近找到最近的距离，主要在两个优化上：

1. 用 \(f_u\) 记录距离 \(u\) 最近的黑点的距离，每次只更新 \(f_v > f_u+1\) 的情况，能有效减小bfs的范围。
2. 用 \(ans\) 答案来限制搜索深度，因为距离大于 \(ans\) 的点没必要更新了，下一次更新 \(ans\) 一定在 \(f_u \leq ans-1\) 的情况。

证明：

在前 \(\sqrt n\) 次，一定能使得 \(ans\) 小于等于 \(2\sqrt n\) ，期间最多遍历 \(n\sqrt n\) 次。

在这之后，优化1能保证每个点只会在 \(f\) 变小时被遍历，优化2保证更新的距离不超过 \(ans \leq 2\sqrt n\) 。综上，每个点的 \(f\) 最多只会被更新 \(2\sqrt n\) 次，即每个点遍历不会超过 \(2 \sqrt n\) 次。

综上复杂度是 \(O(n\sqrt n)\)

时间复杂度 \(O(n \sqrt n)\)

空间复杂度 \(O(n)\)

方法二

知识点：根号分治，dfs，贪心。

不同于方法一的bfs遍历，这种方法设 \(f_u\) 为以 \(u\) 为根的子树中到 \(u\) 最近的黑点的距离，这样每次只需要更新 \(u\) 到根节点 \(1\) 路径上的点即可，并且保证更新层数不超过当前的 \(ans\) ，就可以做到和方法一一样的复杂度，但实际上跑的更快。

证明同方法一类似，前 \(\sqrt n\) 次能让 \(ans \leq 2\sqrt n\) ，后续每次遍历不超过 \(ans \leq 2\sqrt n\) 个点。

时间复杂度 \(O(n\sqrt n)\)

空间复杂度 \(O(n)\)

代码

方法一

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct Graph {
    struct edge {
        int v, nxt;
    };
    int idx;
    vector<int> h;
    vector<edge> e;

    Graph(int n, int m):idx(0), h(n + 1), e(m + 1) {}
    void init(int n) {
        idx = 0;
        h.assign(n + 1, 0);
    }

    void add(int u, int v) {
        e[++idx] = { v,h[u] };
        h[u] = idx;
    }
};
const int N = 200007, M = N << 1;
int c[N];
Graph g(N, M);
int f[N];

bool solve() {
    int n;
    cin >> n >> c[1];
    for (int i = 2;i <= n;i++) cin >> c[i];
    g.init(n);
    for (int i = 1;i < n;i++) {
        int u, v;
        cin >> u >> v;
        g.add(u, v);
        g.add(v, u);
    }

    for (int i = 1;i <= n;i++) f[i] = n + 1;
    int ans = n + 1;
    for (int i = 1;i <= n;i++) {
        ans = min(ans, f[c[i]]);
        f[c[i]] = 0;
        queue<int> q;
        q.push(c[i]);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            if (f[u] >= ans - 1) continue;
            for (int j = g.h[u];j;j = g.e[j].nxt) {
                int v = g.e[j].v;
                if (f[v] > f[u] + 1) {
                    f[v] = f[u] + 1;
                    q.push(v);
                }
            }
        }
        if (i > 1) cout << ans << " \n"[i == 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;
}

方法二

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct Graph {
    struct edge {
        int v, nxt;
    };
    int idx;
    vector<int> h;
    vector<edge> e;

    Graph(int n, int m):idx(0), h(n + 1), e(m + 1) {}
    void init(int n) {
        idx = 0;
        h.assign(n + 1, 0);
    }

    void add(int u, int v) {
        e[++idx] = { v,h[u] };
        h[u] = idx;
    }
};
const int N = 200007, M = N << 1;
int c[N];
Graph g(N, M);
int fa[N];
int f[N];

void dfs(int u, int fa) {
    ::fa[u] = fa;
    for (int i = g.h[u];i;i = g.e[i].nxt) {
        int v = g.e[i].v;
        if (v == fa) continue;
        dfs(v, u);
    }
}

bool solve() {
    int n;
    cin >> n >> c[1];
    for (int i = 2;i <= n;i++) cin >> c[i];
    g.init(n);
    for (int i = 1;i < n;i++) {
        int u, v;
        cin >> u >> v;
        g.add(u, v);
        g.add(v, u);
    }
    dfs(1, 0);

    for (int i = 1;i <= n;i++) f[i] = n + 1;
    int ans = n + 1;
    for (int i = 1;i <= n;i++) {
        int u = c[i], dis = 0;
        while (u && dis < ans) {
            ans = min(ans, dis + f[u]);
            f[u] = min(f[u], dis);
            dis++;
            u = fa[u];
        }
        if (i > 1)cout << ans << " \n"[i == 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;
}

G

题意

给一张 \(n\) 个点 \(m\) 条边的连通无向图，在图上的 \(b\) 个点会存在 bonus 标记（不可移动）。游戏开始前，会存在 \(p\) 个 token 在图点上，可以按照以下步骤移动：

1. 开局可以随意移动一个。
2. 若某次 token 移动到了 bonus 点，那么可以有一次移动其他 token 机会。
3. token 可以重叠。
4. 某次移动使得 token 到编号为 \(1\) 的点，则游戏立刻胜利。

问游戏是否会胜利。

题解

知识点：模拟，贪心，枚举。

我们从两方面考虑：

1. 能使 token 到达 \(1\) 的路径。
2. token 能提供多少次移动机会。

先考虑何种路径才能到达 \(1\) 。为了保证每次移动都有下次机会，那么到 \(1\) 的路径除了起点和终点 \(1\) 都必须是 bonus 点。同时，我们还需要知道移动几次才能到达 \(1\) ，方便后面比较其他点的贡献。因此，我们从 \(1\) bfs，遇到不是 bonus 的点只更新距离，不放队列扩展。

再考虑 token 能提供多少机会。在此之前，我们对 bonus 点的性质进行讨论，发现如果 bonus 点相邻另一个 bonus 点，那么进入这个 bonus 点就能提供无限次机会，而剩下一些孤儿 bonus 点，则进入这个点只会提供一次机会，因此我们先对 bonus 点记录是否无限的状态，这个可以在建图的时候就处理好。之后，我们遍历所有 token ，如果他们的邻居是无限 bonus 点则可以提供无限次机会，这里可以记为 \(n\) 次；如果他们的邻居是孤儿 bonus 点则只能提供一次，记为 \(1\) 次。

最后我们求出 token 贡献总和，枚举每个 token 点判断能否到达 \(1\) 。如果可达，则减去这个点的贡献求出其他点的总贡献，如果其他点的贡献大于等于距离减 \(1\) （开局第一次移动不需要任何 bonus ）则一定可以到达。

时间复杂度 \(O(n+m)\)

空间复杂度 \(O(n+m)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;


const int N = 200007;
vector<int> g[N];
int st[N], dis[N], val[N];

bool solve() {
    int n, m;
    cin >> n >> m;
    int p, b;
    cin >> p >> b;
    for (int u = 1;u <= n;u++) st[u] = 0, g[u].clear(), dis[u] = -1, val[u] = 0;
    for (int i = 1, x;i <= p;i++) cin >> x, st[x] |= 1;
    for (int i = 1, x;i <= b;i++) cin >> x, st[x] |= 2;
    for (int i = 1;i <= m;i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
        if ((st[u] & 2) && (st[v]) & 2) {
            st[u] |= 4;
            st[v] |= 4;
        }
    }
    dis[1] = 0;
    queue<int> q;
    q.push(1);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (auto v : g[u]) {
            if (~dis[v]) continue;
            dis[v] = dis[u] + 1;
            if (st[v] & 2) q.push(v);
        }
    }
    for (int u = 1;u <= n;u++) if (st[u] & 1) for (auto v : g[u]) if (st[v] & 2) { val[u] = st[v] & 4 ? n : 1;if (st[v] & 4) break; }
    ll sum = 0;
    for (int u = 1;u <= n;u++) if (st[u] & 1) sum += val[u];
    for (int u = 1;u <= n;u++) if (st[u] & 1) if (~dis[u] && sum - val[u] >= dis[u] - 1) { cout << "YES" << '\n'; return true; }
    return false;
}

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;
}