【2025 华中师范大学-菜鸟杯程序设计竞赛】部分题解

比赛链接

A. 期末复习

题目大意

给定 $T$ 组数据，每组给定三个正整数 $n,m,k$。

对于一个 $n\times m$ 的矩形，现在要求你做以下操作若干次，问能否使得 至少 $60\%$ 的方块被选中，如果不能输出 $-1$；否则每次操作要花费 $k$ 元，求 最小花费。

• 每次操作选择一些小方块组成的 $\mathrm{L}$ 形方格，要求这个 $\mathrm{L}$ 一定不能是一根棍，也不能是一个点。

数据范围

• $1\le T\le 10^5,$
• $1\le n,m,k\le 10^9.$

Solution1

一个显然的想法是每次选一个最大的 $\mathrm{L}$，即选择边界的 $\mathrm{L}$，这就启发我们从边界的 $n+(m-1)$ 个方块组成的 $\mathrm{L}$ 选起，再转个 $180^{\circ }$ 选择另一半的 $(n-1)+(m-2)$ 个方块 $\mathrm{L}$，一直选到不能选，因此在正常情况下我们最多可以选择 $\min (n,m)-1$ 轮 $\mathrm{L}$。

设 $\mathrm{sum}=\lceil \frac{\mathrm{n}\times \mathrm{m}\times 6}{10}\rceil$，表示至少要选择的方块数。

首先 $\min (n,m)=1$ 那么一定无解，因为题目不允许选择一个竖直或者横着的棍子。

其次是 $\min (n,m)=2$ 的情况。这种情况下需要特判。

• 如果 $n+(m-1)\ge \mathrm{sum}$，说明选了第一个边界 $\mathrm{L}$ 就可以走人了，花费 $k$ 元；
• 否则 $n+(m-1)<\mathrm{sum}$，说明不能直接把第一个边界 $\mathrm{L}$ 全部选掉，应该留一块给对称的另一半，这样可以直接选完所有方块（想象一下 $\mathrm{L}$ 和 $7$ 插在一起），花费 $2k$ 元。

$\min (n,m)>2$ 的情况就一定可以满足了，后面给出证明，下面先谈计算。

设我们选了 $c$ 轮，那就是 $$\begin{array}{rl}\sum _{i=1}^c((n-i+1)+(m-i))& =\sum _{i=1}^c((n+m)-(2i-1))\\ & =\sum _{i=1}^c(n+m)-\sum _{i=1}^c(2i-1)\\ & =(n+m)\cdot c-c^2\\ & =(n+m-c)\cdot c.\end{array}$$

而我们就是要求最小的 $c$，使得 $(n+m-c)\cdot c\ge sum$，这可以通过 二分 实现。最终答案就是 $ck$。

下面是 $\min (n,m)>2$ 一定可以满足题目要求的证明。

我们最多可以进行 $\min (n,m)-1$ 轮，根据上面推导的公式，一共可以选择 $$(n+m-(\min (n,m)-1))\cdot (\min (n,m)-1)$$ 个方块，根据 $n+m=\max (n,m)+\min (n,m)$，化简一下就是 $$(\max (n,m)+1)\cdot (\min (n,m)-1)$$ 根据对称性，不妨设 $n>m$，那么就是 $(n+1)(m-1)$，即选择了 $nm-(n-m)-1$ 个方块，我们只需说明 $nm-(nm-(n-m)-1)=(n-m)+1$ 最多只占总和 $nm$ 的 $40\%$ 即可。

只需证 $$(n-m)+1\le \lfloor \frac{2nm}{5}\rfloor .$$

考虑 $\lfloor x\rfloor \ge x-1$，于是我们再换一个目标，想办法证明 $$(n-m)+1\le \frac{2nm}{5}-1\le \lfloor \frac{2nm}{5}\rfloor .$$

化简一下得到 $$2nm-5(n-m)\ge 10,$$ 即 $$(2m-5)n+5m\ge 10.$$

由于 $\min (n,m)>2$，那就有 $$\begin{gathered} (2m-5)n\ge (2\cdot 3-5)\cdot 3=3, \\ 5m\ge 5\cdot 3=15, \end{gathered}$$

综上得到 $$(2m-5)n+5m\ge 3+15=18\ge 10.$$

$n\le m$ 的情况同理可证。

时间复杂度 $O(\sum \log \mathrm{nm})$

C++ Code for Solution1

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;

    int maxc = std::min(n, m);
    if (maxc == 1) {
        std::cout << -1 << "\n";
        return;
    }
    i64 sum = (3LL * n * m - 1) / 5 + 1;
    if (maxc == 2) {
        int ans = k * (1 + (sum > n + m - 1));
        std::cout << ans << "\n";
        return;
    }
    auto calc = [&](int c) {
        return static_cast<i64>(n + m - c) * c;
    };
    int lo = 1, hi = maxc;
    while (lo + 1 < hi) {
        int m = lo + hi >> 1;
        if (calc(m) >= sum) {
            hi = m;
        } else {
            lo = m;
        }
    }
    std::cout << static_cast<i64>(k) * hi << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
    
    int T = 1;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

Solution2

上面说到，求使得 $(n+m-c)\cdot c\ge \mathrm{sum}$ 的最小的 $c$ 可以用二分，但是注意到这是个关于 $c$ 的二次不等式，所以可以考虑用求根公式 $O(1)$ 求解。

把不等式变为 $c^2-(n+m)c+\mathrm{sum}\le 0$ 后，考虑 $$\Delta =(n+m{)}^2-4\mathrm{sum}\ge (2\sqrt{\mathrm{nm}}{)}^2-4\mathrm{sum}=4(\mathrm{nm}-\mathrm{sum})>0,$$ 再用求根公式得到两个根

$$\begin{gathered} c_1=\frac{(n+m)-\sqrt{(n+m{)}^2-4\mathrm{sum}}}{2}, \\ {c}_2=\frac{(n+m)+\sqrt{(n+m{)}^2-4\mathrm{sum}}}{2}. \end{gathered}$$

那么 $c$ 的范围就是 $[\max (\lceil c_1\rceil ,1),\min (\lfloor c_2\rfloor ,\min (n,m)-1)]$。

所以满足条件的最小的 $c$ 是 $\max (\lceil c_1\rceil ,1)$，而 $(n+m)>\sqrt{(n+m{)}^2-4\mathrm{sum}}$，因此 $\lceil c_1\rceil \ge 1$，因此最小的 $c$ 就是 $\lceil c_1\rceil$。

至于解的存在性在 $Solution1$ 中已有证明。

时间复杂度 $O(T)$

C++ Code for Solution2

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;

    int maxc = std::min(n, m);
    if (maxc == 1) {
        std::cout << -1 << "\n";
        return;
    }
    i64 sum = (3LL * n * m - 1) / 5 + 1;
    if (maxc == 2) {
        std::cout << k * (1 + (sum > n + m - 1)) << "\n";
        return;
    }
    i64 c = std::ceil(((n + m) - std::sqrt(static_cast<i64>(n + m) * (n + m) - 4 * sum)) / 2);
    std::cout << c * k << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
    
    int T = 1;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

B. 洛杉矶的火

题面大意

给定 $n$ 个点 $(x_i,y_i),i\in [1,n]$ 以及一个纵坐标 $h$，你现在在 $(x_0,y_0)$，要求你以某个顺序走完这 $n$ 个点，求走过的最短距离（用曼哈顿距离）。

• 注意题目 特别规定，每次从 $(x_{i_k},y_{i_k})$ 出发，必须先以某种方式（横着+竖着）走到纵坐标 $h$，即 $(x^{\prime },h)$，再走到 $(x_{i_{k+1}},y_{i_{k+1}})$；
• 其中 $i_k$ 表示第 $k$ 个经过的点的原下标为 $i_k$，$x^{\prime }$ 表示任意横坐标。

数据范围

• $1\le \sum n\le 2\cdot 10^5,$
• $-10^9\le h,x_0,y_0\le 10^9,$
• $-10^9\le x_i,y_i\le 10^9,$
• 保证任意两对 $(x_i,y_i)$ 和 $(x_j,y_j)$ 不同。

Solution

首先假设走的顺序 $i_1,i_2,\cdots ,i_n$，然后列公式。特别规定 $i_0=0$。

每一次行走流程按顺序展示如下：

• 从 $(x_{i_{k-1}},y_{i_{k-1}})$ 到某个 $(x^{\prime },h)$，显然 $x^{\prime }=x_{i_{k-1}}$ 最佳，那么这一段行走的曼哈顿距离就是 $$|y_{i_{k-1}}-h|,$$
• 从 $(x_{i_{k-1}},h)$ 到 $(x_{i_k},y_{i_k})$，这一段行走的曼哈顿距离为 $$|x_{i_k}-x_{i_{k-1}}|+|y_{i_k}-h|.$$

所以总共走过的距离是 $$\sum _{k=1}^n|y_{i_{k-1}}-h|+|x_{i_k}-x_{i_{k-1}}|+|y_{i_k}-h|.$$

整理一下就会变成 $$\left(|y_0-h|+2\left(\sum _{k=1}^n|y_{i_k}-h|\right)\right)+\left(\left(\sum _{k=1}^n|x_{i_k}-x_{i_{k-1}}|\right)-|y_{i_n}-h|\right).$$

可以发现，前半括号里都是不变量，而后半括号主要跟结尾的 $y_{i_n}$ 以及遍历 $x$ 的顺序有关，这就启发我们枚举结尾处坐标 $(x_{i_n},y_{i_n})$，然后用某种方式知道遍历的顺序。

那么怎么知道遍历的顺序呢？容易想到，如果能尽量让 $x$ 升序或者降序是最好的，实在不行，就要先遍历 终点关于起点异侧的那些点。

比如说终点的横坐标 $x_e=0$，起点的横坐标 $x_s=2$，那我们就要优先选择遍历 $x^{\prime }>2$ 的部分。设这 $n+1$ 个点中最小的横坐标为 $\mathrm{minx}$，最大的横坐标为 $\mathrm{maxx}$，这样贪心得到的结果就是 $$2(\mathrm{maxx}-\mathrm{minx})-|{\mathrm{x}}_{\mathrm{e}}-{\mathrm{x}}_{\mathrm{s}}|.$$

所以只要先预处理好前面的不变量，以及 $2(\mathrm{maxx}-\mathrm{minx})$，就可以 $O(n)$ 出结果了。

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

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

void solve() {
    int n, h, x0, y0;
    std::cin >> n >> h >> x0 >> y0;

    std::vector<int> x(n);
    std::vector<int> y(n);
    for (int i = 0; i < n; i++) {
        std::cin >> x[i] >> y[i];
    }

    i64 sum = 0;
    for (int i = 0; i < n; i++) {
        sum += std::abs(y[i] - h);
    }
    int maxx = std::ranges::max(x);
    int minx = std::ranges::min(x);
    i64 dis = 2LL * (std::max(x0, maxx) - std::min(x0, minx));
    i64 ans = std::numeric_limits<i64>::max() / 4;
    for (int i = 0; i < n; i++) {
        i64 res = 2 * sum - std::abs(y[i] - h);
        res += dis - std::abs(x[i] - x0);
        ans = std::min(ans, res);
    }
    std::cout << ans + std::abs(y0 - h) << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
    
    int T = 1;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

C. 好数

题目大意

我们称正整数 $x$ 为好数当且仅当存在正整数$l,r$ 满足 $l<r$，使得 $x=\sum _{i=l}^{r}i$。

给定 $T$ 组数据，每组给出一个区间 $[L,R]$。

对于每个 $[L,R]$，问 $[L,R]$ 中有多少个好数。

数据范围

• $1\le T\le 10^4,$
• $1\le L\le R\le 10^{18}.$

Solution

这个题其实是个经典结论了。我们考虑 $$x=\sum _{i=l}^{r}i=\frac{(r+l)(r-l+1)}{2},$$ 不论 $l,r$ 的奇偶，$r+l$ 和 $r-l$ 的奇偶性一定是一样的，所以 $(r+l)(r-l+1)$ 一定是一个偶（奇）数一个奇（偶）数，且那个奇数一定 $\ge 3$（题目规定 $l<r$），而最后还要除以 $2$，所以 $x$ 一定不可能是 $2^k(k\in N)$。

那么除了 $2^k$，其他的正整数都能凑出来吗？打表可知确实可以，下面进行证明。

• 若 $x$ 是（$\ge 3$ 的）奇数，那么有 $$x=\frac{x-1}{2}+\frac{x+1}{2},$$ 取 $l=\frac{x-1}{2},r=\frac{x+1}{2}$ 即可。
• 若 $x$ 是（$\ne 2^k,\forall k\in N$） 的偶数，那么一定有 $$x=a\cdot b,$$ 不妨设 $a$ 为奇数（一定 $\ge 3$），$b$ 为偶数。
  • 若 $b>\frac{a-1}{2}$，那就构造 $$\sum _{i=b-\frac{a-1}{2}}^{b+\frac{a-1}{2}}i=\frac{a-1}{2}(2b)+b=a\cdot b=x,$$
  • 否则就有 $b\le \frac{a-1}{2}<\frac{a+1}{2}$，于是构造 $$\begin{array}{rl}\sum _{i=\frac{a+1}{2}-b}^{\frac{a+1}{2}+b-1}i& =\left(\sum _{i=\frac{a+1}{2}-b}^{\frac{a+1}{2}+b}i\right)-\left(\frac{a+1}{2}+b\right)\\ & =b\cdot (a+1)+\frac{a+1}{2}-\left(\frac{a+1}{2}+b\right)\\ & =b\cdot (a+1)-b\\ & =b\cdot a\\ & =x\end{array}$$

综上，除了 $2^k(k\in N)$ 都能用连续自然数的和凑出来。

时间复杂度 $O(T)$

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

int lg(i64 x) {
    return x > 0 ? std::__lg(x) + 1: 0;
}

void solve() {
    i64 L, R;
    std::cin >> L >> R;
    L--;
    std::cout << (R - L) - (lg(R) - lg(L)) << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
	
    int T = 1;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

E. 交换offer

题目大意

给定 $T$ 组数据，每组给定一个正整数 $n$，表示人数。

这 $n$ 个人每人有一份 $\mathrm{offer}$，每个人都可以将自己的 $\mathrm{offer}$ 随机交给其他人，问所有人都拿不到自己原来 $\mathrm{offer}$ 的概率是多少，答案对 $998244353$ 取模。

数据范围

• $1\le T\le 10^4,$
• $2\le n\le 2\cdot 10^6.$

Solution

其实就是一个全错排问题，设 $D_n$ 表示 $n$ 个人的全错排数量，那么递推式就是

$$D_n=(n-1)(D_{n-1}+D_{n-2}),$$

初值条件：$D_1=0,D_2=1$。

其含义可以用 $\mathrm{dp}$ 的转移方程来理解。

假设我们要将元素 $n$ 排列到某个位置，但由于是错排，它不能出现在位置 $n$ 上，所以我们有 $n-1$ 种选择来将元素 $n$ 放到其他位置。

假设 元素 $n$ 被放置在位置 $i\in [1,n)$，那么我们就需要考虑剩余 $n-1$ 个元素的错排。这个时候，我们有两种情况需要处理：

• 元素 $i$ 被放置到位置 $n$。这种情况下，剩下的 $n-2$ 个元素错排;
• 元素 $i$ 被放置到其他位置（$\ne n$），此时我们需要将剩余的 $n-1$ 个元素错排。

最终答案就是 $$\frac{D_n}{(n-1{)}^n}.$$

时间复杂度 $O(\max (\mathrm{n})+\sum \log \mathrm{n})$

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
template<int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}
     
    static int Mod;
    constexpr static int getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) & {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
};
 
template<>
int MInt<0>::Mod = 998244353;
 
template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();
 
constexpr int P = 998244353;
using Z = MInt<P>;

std::vector<Z> D;

void init(int n) {
    D.assign(n + 1, 0);
    D[2] = 1;
    for (int i = 3; i <= n; i++) {
        D[i] = (i - 1) * (D[i - 1] + D[i - 2]);
    }
}

void solve() {
    int n;
    std::cin >> n;
    std::cout << (D[n] / power(Z(n - 1), n)) << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
    
    init(2000000);

    int T = 1;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

F. 植树节

题目大意

原题是 $\mathrm{codeforces}$ 的一道题：CF1363C Game On Leaves。

给定一棵 $N$ 个结点的树，$\mathrm{Alice}$ 和 $\mathrm{Bob}$ 两人在树上博弈。一开始你指定了一个结点 $X\in [1,N]$。现在他们要轮流删除结点，$\mathrm{Alice}$ 先手。

• 每次删除的结点只能是度为 $1$ 的结点（也就是叶节点），且同时要删掉这条悬挂边。

谁先删掉 $X$ 谁就获胜，问谁能获胜。

数据范围

• $1\le X\le N\le 5\cdot 10^5.$

Solution

如果 $X$ 是叶结点，那么先手必胜。

如果 $X$ 不是叶节点，我们可以把 $X$ 拎起来，让 $X$ 作为根节点，然后按照层序遍历的逆序往上删除，那么删到最后一定剩下两个结点，一个是 $X$，一个是下面挂着的它的其中一个儿子 $Y$，此时 $X$ 也是叶结点了，所以先到这个状态的必胜。

如果 $(N-1)\equiv 1(\mathrm{mod}2)$，说明上面所说的状态是奇数次被访问到的，也就是 $\mathrm{Alice}$ 必胜，因此 $N\equiv 0(\mathrm{mod}2)$ 则先手必胜。

时间复杂度 $O(N)$

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N;
    std::cin >> N;

    std::vector<int> deg(N);
    for (int i = 1; i < N; i++) {
        int u, v;
        std::cin >> u >> v;
        u--, v--;
        deg[u]++;
        deg[v]++;
    }

    int X;
    std::cin >> X;
    X--;

    if (deg[X] == 1 or N % 2 == 0) {
        std::cout << "xiaonian wins!\n";
    } else {
        std::cout << "coldtree wins!\n";
    }
    
    return 0;
}

G. 逻辑门

题目大意

这个只能在题面里看图，没法细说。

Solution

就是跟找规律一样，最终出来的是个这样的结构，大家看久一点就能发现规律了，太难用语言描述了（其中 $\oplus$ 表示异或，$\otimes$ 表示按位与，$\mid$ 表示按位或）。

$$\begin{array}{rl}(& a_1\oplus a_2)\\ (& a_1\otimes a_2)\oplus (a_3\oplus a_4)\\ (((& a_1\otimes a_2)\otimes (a_3\oplus a_4))\mid (a_3\otimes a_4))\oplus (a_5\oplus a_6)\\ (((((& a_1\otimes a_2)\otimes (a_3\oplus a_4))\mid (a_3\otimes a_4))\otimes (a_5\oplus a_6))\mid (a_5\otimes a_6))\oplus (a_7\oplus a_8)\\ & \cdots \end{array}$$

时间复杂度 $O(N)$

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

template<class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
    for (const auto &x: v) {
        os << x;
    }
    return os;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;

    std::vector<int> a(n);
    for (int i = 0; i < n; i++) {
        char c;
        std::cin >> c;
        a[i] = c - '0';
    }

    std::vector<int> ans(n / 2 + 1);

    int sum = a[0] & a[1];   
    ans[n / 2] = a[0] ^ a[1];
    ans[n / 2 - 1] = sum ^ (a[2] ^ a[3]);
    for (int i = 4; i + 2 <= n; i += 2) {
        sum = (sum & (a[i - 2] ^ a[i - 1])) | (a[i - 2] & a[i - 1]);
        ans[n / 2 - i / 2] = sum ^ (a[i] ^ a[i + 1]);
    }
    sum = (sum & (a[n - 2] ^ a[n - 1])) | (a[n - 2] & a[n - 1]);
    ans[0] = sum;

    std::cout << ans << "\n";
    
    return 0;
}

I. 找出躺赢狗

Solution

模拟题，直接存分数和名字排序即可，这里浮点误差远到不了 $0.1$ 的程度，但是我为了写 $\mathrm{int}$ 的（比较好看），所以用字符串处理了一下。

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n;
    std::cin >> n;

    std::vector<std::pair<int, std::string>> ans;
    for (int i = 0; i < n; i++) {
        std::string s;
        std::string t;
        std::cin >> s >> t;
        
        int score = 0;
        int p = t.find('.');
        if (p == -1) {
            score = std::stoi(t) * 10;
        } else {
            score = std::stoi(t.substr(0, p)) * 10 + std::stoi(t.substr(p + 1));
        }
        if (score <= 30) {
            ans.emplace_back(score, s);
        }
    }

    std::ranges::sort(ans);

    std::cout << ans.size() << "\n";
    for (const auto &[score, name]: ans) {
        std::cout << name << "\n";
    }
    
    return 0;
}

J. 音名

Solution

也是模拟题，直接开一个字符串 $\mathrm{CDEFGAB}$，然后找给定音名在这个字符串中的位置即可。

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

using namespace std::literals::string_literals;

auto s = "CDEFGAB"s;

void solve() {
    char a, b;
    std::cin >> a >> b;
    if (s.find(a) < s.find(b)) {
        std::cout << b << "\n";
    } else {
        std::cout << a << "\n";
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
    
    int T = 1;
    std::cin >> T;
    
    while (T--) {
        solve();
    }
    
    return 0;
}

K. 昆明的雨

题目大意

给定一棵 $n$ 个节点的树、一个正整数 $m$ 和一个正整数数组 $w$。

• 长度为 $n$ 的数组 $w$，$w_i$ 表示第 $i$ 个结点的权值；
• 若选择的结点满足 $\left(\sum _{iischosen}{w}_i\right)\le m$，我们称其为 合法 的选择。

现在给定 $q$ 个询问（每个询问独立），每个询问给出 $x,y\in [1,n]$，若你只能选择从 $1$ 到 $x$ 的简单路径上的结点，且不能选择 $y$，求有多少种 合法 的选择方案，答案对 $998244353$ 取模。

数据范围

• $2\le n,m,q\le 5000,$
• $1\le w_i\le m,$
• $1\le x,y\le n,$
• 不保证 $y$ 在 $1$ 到 $x$ 的简单路径上。

Solution

首先，如果没有不能选择 $y$ 的限制，这就是一个基本的树上背包。

下面的讨论都是基于这棵树以 $1$ 为根。

设 $\mathrm{dp}[\mathrm{x}][\mathrm{s}]$ 表示从 $1$ 到 $x$ 这条简单路径上选择的结点权值总和为 $s$ 的方案数，$y$ 为 $x$ 其中一个儿子，显然有转移方程：

• 不选 $y$：$\mathrm{dp}[\mathrm{y}][\mathrm{s}]:=\mathrm{dp}[\mathrm{y}][\mathrm{s}]+\mathrm{dp}[\mathrm{x}][\mathrm{s}],\forall s\in [0,\mathrm{m}],$
• 选择 $y$：$\mathrm{dp}[\mathrm{y}][\mathrm{s}]:=\mathrm{dp}[\mathrm{y}][\mathrm{s}]+\mathrm{dp}[\mathrm{x}][\mathrm{s}-{\mathrm{w}}_{\mathrm{y}}],\forall s\in [{\mathrm{w}}_{\mathrm{y}},\mathrm{m}].$

初值条件：$\mathrm{dp}[1][{\mathrm{w}}_1]=\mathrm{dp}[1][0]=1$。

• 注意只需要赋根节点的初值，其他结点的 $\mathrm{dp}$ 值在转移过程中就会正确计算。

现在再考虑 $y$ 可能是 $x$ 的祖先的情况，这可以用 $\mathrm{dfs}$ 序进行判断（见代码中的 $\mathrm{in},\mathrm{out}$ 数组）。

• 若 $y$ 不是 $x$ 的祖先，也就不在 $1$ 到 $x$ 的简单路径上，直接输出 $$\sum _{s=0}^m\mathrm{dp}[\mathrm{x}][\mathrm{s}].$$
• 否则考虑另一个 $\mathrm{dp}$。设 $\mathrm{ndp}[\mathrm{x}][\mathrm{s}]$ 表示从 $1$ 到 $x$ 这条简单路径上选择的结点权值总和为 $s$ 的方案数，且不选 $x$。那么就有 $$\mathrm{dp}[\mathrm{x}][\mathrm{s}]=\mathrm{ndp}[\mathrm{x}][\mathrm{s}]+\mathrm{ndp}[\mathrm{x}][\mathrm{s}-{\mathrm{w}}_{\mathrm{x}}],$$ 其中 $\mathrm{ndp}[\mathrm{x}][\mathrm{s}]$ 表示确定不选 $x$，$\mathrm{ndp}[\mathrm{x}][\mathrm{s}-{\mathrm{w}}_{\mathrm{x}}]$ 表示已经 选完 $x$ 后，不再给选 $x$ 的机会。那么移项后就是 $$\mathrm{ndp}[\mathrm{x}][\mathrm{s}]=\mathrm{dp}[\mathrm{x}][\mathrm{s}]-\mathrm{ndp}[\mathrm{x}][\mathrm{s}-{\mathrm{w}}_{\mathrm{x}}],$$ 同时我们发现 $\mathrm{ndp}$ 第一维的 $x$ 没用，所以直接去掉，变成 $$\mathrm{ndp}[\mathrm{s}]=\mathrm{dp}[\mathrm{x}][\mathrm{s}]-\mathrm{ndp}[\mathrm{s}-{\mathrm{w}}_{\mathrm{x}}].$$ 最后输出 $$\sum _{s=0}^m\mathrm{ndp}[\mathrm{s}].$$

时间复杂度 $O(\mathrm{nm}+\mathrm{qm})$

• 预处理 $\mathrm{dp}$ 是 $O(nm)$；
• 最坏情况下每次询问都处理一遍 $\mathrm{ndp}$，所以是 $O(qm)$。

C++ Code

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using i80 = __int128_t;
using u80 = unsigned __int128_t;
using f64 = double;
using f80 = long double;
using i16 = short;
using u16 = unsigned short;

constexpr f64 pi = std::numbers::pi;

template<class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
    for (auto &x: v) {
        is >> x;
    }
    return is;
}

template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
template<int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}
     
    static int Mod;
    constexpr static int getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) & {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
};
 
template<>
int MInt<0>::Mod = 998244353;
 
template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();
 
constexpr int P = 998244353;
using Z = MInt<P>;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, m;
    std::cin >> n >> m;

    std::vector<int> w(n);
    std::cin >> w;

    std::vector<std::vector<int>> adj(n);
    for (int i = 1; i < n; i++) {
        int u, v;
        std::cin >> u >> v;
        u--, v--;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    std::vector dp(n, std::vector<Z>(m + 1));
    dp[0][w[0]] = 1;
    dp[0][0] = 1;

    int idx = 0;
    std::vector<int> in(n);
    std::vector<int> out(n);
    auto dfs = [&](auto &&self, int x) -> void {
        in[x] = idx++;
        for (int y: adj[x]) {
            adj[y].erase(std::ranges::find(adj[y], x));
            for (int s = 0; s <= m; s++) {
                dp[y][s] += dp[x][s];
            }
            for (int s = w[y]; s <= m; s++) {
                dp[y][s] += dp[x][s - w[y]];
            }
            self(self, y);
        }
        out[x] = idx;
    };
    dfs(dfs, 0);

    auto isAnc = [&](int u, int v) {
        return in[u] <= in[v] and in[v] < out[u];
    };

    int q;
    std::cin >> q;

    while (q--) {
        int x, y;
        std::cin >> x >> y;
        x--, y--;

        auto ndp = dp[x];
        if (isAnc(y, x)) {
            for (int s = w[y]; s <= m; s++) {
                ndp[s] = dp[x][s] - ndp[s - w[y]];
            }
        }
        std::cout << std::accumulate(ndp.begin(), ndp.end(), Z(0)) << "\n";
    }
    
    return 0;
}