[新手向]蓝桥杯2025省赛C++/B组个人题解

另一种阅读体验：https://zhuanlan.zhihu.com/p/1895276194334766227

争取在省赛前做到每周至少更五篇博客

因为是新手向，所以我会尽可能写的详细点（

前言

本文的题解代码均为solve()单独函数，基于以下代码为基础，这一块完全可以掠过不看

#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;

typedef std::pair<long long, long long> PII;
const int mod = 998244353;
const int N = 2e6 + 1000;
const int INF = 0x3f3f3f3f;
const long long LINF = 1e18;
const double eps = 1e-12;
const double pi = std::acos(-1);
std::mt19937_64 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
std::uniform_int_distribution<u64> dist_rand(mod / 2, mod - 1);

void solve() {
    
}

signed main() {
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    
    int tmp = 1;
    
    std::cin >> tmp;

    while (tmp--)
        solve();

    return 0;
}

可分解的正整数

思路

当然这题有很多神秘的数学解法，但关键在于负数也可以参与到序列中，那么有
$$x=\sum _{i=-(x-1)}^{0}i+\sum _{i=0}^{x-1}i+x$$
其中$\sum$表示累加，例如${\sum }_{i=1}^{3}i=1+2+3$

$-(x-1)+-(x-2)+(-2)+(-1)\cdots +0+1+2\cdots +(x-2)+(x-1)=0$

最后加上$x$即可完成我们的序列

事实上当$x>1$时都可以满足要求，因为$x = 2 $时有$[-1, 0, 1, 2]$，此时长度大于$3$，比$2$大的数的序列只会更大

考虑边界情况$x=1$，此时是无法组成合法序列的

所以答案是数组中元素值不等于$1$的个数

代码

void solve() {
    int n, ans = 0;
    std::cin >> n;
    for (int i = 1; i <= n; i++) {
        int x;
        std::cin >> x;
        if (x != 1) ans ++;
    }
    std::cout << ans << '\n';
}

产值调整

思路

正解与暴力的区别在于if (a == A && b == B && c == C) break;的一个特判

通过打表我们可以发现执行次数其实最多执行$\log$级别的次数，每次迭代都会使三个数逐渐趋于相同，所以只需要判断下什么时候迭代不会对三个数产生影响就可以

时间复杂度是$O(t\log (A))$，其中$A$是$a,b,c$的值域上限

代码

void solve() {
    int a, b, c, k;
    std::cin >> a >> b >> c >> k;

    for (int i = 1; i <= k; i++) {
        int A = (b + c) / 2;
        int B = (a + c) / 2;
        int C = (a + b) / 2;
        if (a == A && b == B && c == C) break;
        a = A, b = B, c = C;
    }
    std::cout << a << ' ' << b << ' ' << c << '\n';
}

画展布置

思路

看到${\sum }_{i=l}^r|a_{i+1}-a_i|$类型的题目，我们应该往排序上思考

因为排序后可以将绝对值去掉，例如我们可以先对数组升序排序，这样子确保$a_{i+1}\ge a_i$，这样子式子变成了${\sum }_{i=l}^r{a}_{i+1}-a_i$，更有助于我们分析题目

同样适用于本题，鉴于本题并不要求元素之间的顺序关系，所以我们可以放心排序，并且如果满足$a>b>0$，那么一定有$a^2>b^2>0$，所以我们可以先对每个元素进行平方后再排序

因为我们希望让${\sum }_{i=l}^r{a}_{i+1}-a_i$尽可能小，实际上在排序后就是让我们选择一个长度为$m$的区间，让这个区间中相互元素差的和尽可能小。如果觉得这里毕竟晦涩难懂，那么我推荐你可以画一个二维坐标系，通过数形结合的方式进行理解

当然我们也可以简单的证明一下，假设有三个数$a_1,a_2,a_3(a_1<a_2<a_3)$，想让元素差尽可能小一定要相邻的数，假设我们选两个数，那么有三种情况$(a_1,a_2),(a_2,a_3),(a_1,a_3)$，差值分别是$a_2-a_1,a_3-a_2,a_3-a_1=(a_3-a_2)+(a_2-a_1)$，显然最后这个差比前两个差只会更高

代码

void solve() {
    int n, m;
    std::cin >> n >> m;
    std::vector<i64> a(n + 1);
    for (int i = 1; i <= n; i++) std::cin >> a[i], a[i] *= a[i];

    std::sort(a.begin(), a.end());

    i64 ans, sum = 0;
    for (int i = 2; i <= m; i ++) sum += a[i] - a[i - 1];
    ans = sum;

    for (int i = m + 1; i <= n; i++) {
        sum -= a[i - m + 1] - a[i - m];
        sum += a[i] - a[i - 1];
        ans = std::min(ans, sum);
    }

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

水质检测

思路

一道很经典的dp题

对于dp题我们都可以直接思考dp的三组件——定义，初始化，转移

解决完这三组件那么这道dp也随之解决了

定义：定义$d{p}_{i,j}$为使得$0$行和$1$行的$[1,j-1]$列区间的检测器都联通的条件下，让$(i,j)$这个地方也变成探测器(即让这个点也联通)的最小花费

初始化：因为字符串的两端有可能都没有探测器，所以是没必要处理这两段的，所以我们可以通过

int l = 1, r = n;
while (c[0][l] + c[1][l] == 2) l ++;
while (c[0][r] + c[1][r] == 2) r --;

来修改我们要dp的范围，使得我们的dp定义合法

这里的$c_{i,j}$表示第$(i,j)$位置是否无探测器，是$.$为$1$，否则为$0$

而关于最初的第一列，三种情况：

1 #  |  2 #  |  3 .   
  #  |    .  |    #

对于第$1$种情况，两个点都已经有探测器，显然有$d{p}_{0/1,1}=0$

对于第$2$种情况，第$0$行第$1$列的点有探测器，第$1$行第$1$列的点无探测器，那么有$d{p}_{0,1}=0,d{p}_{1,1}=1$，因为想让第$(1,1)$位置联通，我们需要在这个位置上放一个探测器

第$3$种情况和第$2$种情况同理

实际上可以简化成$d{p}_{i,1}=c_{i,j}$

转移：对于第$(i,j)$个点的转移也只有三种情况

1
    (i, j - 1)    -> (i, j)
(i + 1, j - 1)       (i + 1, j)
—————————————————————————————————————————————
2
    (i, j - 1)    -> (i, j)
       ↑
(i + 1, j - 1)       (i + 1, j)
——————————————————————————————————————————————
3
    (i, j - 1)       (i, j)
                        ↑
(i + 1, j - 1)    -> (i + 1, j)

实际上上面的$(i+1)$应该是$(i\oplus 1)$，为了便于理解这里让$i$是第$0$行

对于第一种情况，转移为$d{p}_{i,j}\leftarrow d{p}_{i,j-1}+c_{i,j}$，后面的$+c_{i,j}$是如果第$(i,j)$没有探测器的话需要花费$1$的代价添加

第二种情况，转移为$d{p}_{i,j}\leftarrow d{p}_{i\oplus 1,j-1}+c_{i,j-1}+c_{i,j}$

第三种情况，转移为$d{p}_{i,j}\leftarrow d{p}_{i\oplus 1,j-1}+c_{i\oplus 1,j}+c_{i,j}$

取三种情况最小的值进行转移即可

解决完定义，初始化和转移，这道题只需要将上面翻译成代码也就完成了

代码

void solve() {
    std::string s1, s2;
    std::cin >> s1 >> s2;
    int n = s1.size();
    std::vector c(2, std::vector<int>(n + 1));

    for (int i = 1; i <= n; i ++) c[0][i] = s1[i - 1] == '.';
    for (int i = 1; i <= n; i ++) c[1][i] = s2[i - 1] == '.';

    std::vector dp(2, std::vector<int>(n + 1));

    int l = 1, r = n;
    while (c[0][l] + c[1][l] == 2) l ++;
    while (c[0][r] + c[1][r] == 2) r --;

    if (l > r) {
        std::cout << "0\n";
        return ;
    }

    dp[0][l] = c[0][l], dp[1][l] = c[1][l];

    for (int i = l + 1; i <= r; i ++)
        for (int j = 0; j < 2; j ++)
            dp[j][i] = std::min({dp[j][i - 1], dp[j ^ 1][i - 1] + c[j][i - 1], dp[j ^ 1][i - 1] + c[j ^ 1][i]}) + c[j][i];

    std::cout << std::min(dp[0][r], dp[1][r]) << '\n';
}

生产车间

思路

实际上这道题才是本次省赛最难的题目

一句话题解：树上跑可行性01背包用bitset优化

因为这题已经很不新手向了，所以这题不会像上一题写的那么详细

那么同样考虑dp的三组件——定义，初始化，转移

定义$d{p}_{u,s}$，表示以$u$为根的子树是否可以打包值为$s$的数量，$u$节点可以向上打包的值的集合由一串二进制$mask$表示，如果$mas{k}_i=true$表示可以打包值为$i$，否则不可以

考虑初始化，对于每个节点，显然可以把其子树所有节点都删掉，那么也就是打包的值为$0$，即$d{p}_{u,0}=true$；对于叶子节点，因为其可以自己生成，所以有$d{p}_{u,a_u}=true$

考虑转移，对于节点$u$和他的儿子节点$v$，由于每个节点只能选择一个值进行打包，所以这里其实还是个分组的01背包，所以先令$tmp=d{p}_u$，然后用$tmp$去对$d{p}_u$进行转移

如果直接跑$01$背包的话时间复杂度为$O(n{w}^2)$，其中$n$是枚举每个点，$w^2$是对分组背包的每个值都进行一次01背包，这样会超出我们时间限制

不过01背包有个很经典的bitset优化，可以使我们的时间复杂度优化到$O(\frac{n{w}^2}{64})$的程度，这样就可以通过本题了

关于转移，枚举当前要选择$v$打包的值，当$d{p}_{v,i}=true$时，有$d{p}_u\leftarrow d{p}_u|(tmp<<i)$

最后从大到小枚举下根节点能打包的最大值即可

代码

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n + 1);
    for (int i = 1; i <= n; i ++) std::cin >> a[i];
    std::vector go(n + 1, std::vector<int>());
    for (int i = 1; i < n; i ++) {
        int u, v;
        std::cin >> u >> v;
        go[u].emplace_back(v);
        go[v].emplace_back(u);
    }

    std::vector<std::bitset<1001>> dp(n + 1);
    auto dfs = [&](auto &&dfs, int u, int fa) ->void {
        dp[u][0] = true;
        bool leaf = true;
        for (auto v : go[u]) {
            if (v == fa) continue;
            dfs(dfs, v, u);

            auto tmp = dp[u];
            for (int i = 1; i <= a[v]; i ++) if (dp[v][i]) dp[u] |= tmp << i;

            leaf = false;
        }
        if (leaf) dp[u][a[u]] = true;
    };

    dfs(dfs, 1, 1);

    for (int i = a[1]; i >= 0; i --) if (dp[1][i]) {
        std::cout << i << "\n";
        return ;
    };
}

装修报价

思路

代码中的Z变量类型是一个自动取模的变量类型

实际上这道题是一道诈骗题，因为有
$$x=a_1+(a_2+-\oplus a_3\dots )$$
$$y=a_1-(a_2+-\oplus a_3\dots )$$
$$x+y=a_1+a_1$$
实际上几乎只有第一个数有贡献，至于几乎是因为当包含$a_1$的异或中会优先计算异或，所以其他数在这时候会有贡献

考虑枚举异或的区间，左端点只能是$1$，右端点是$i(i<n)$，那么有
$$ans\leftarrow \sum _{i=2}^{n-1}({\oplus }_{j=1}^i{a}_j)\cdot 2\cdot 3^{n-i-1}$$
这里表示$[a_1\oplus a_2\cdots \oplus a_i+...]$和$[a_1\oplus a_2\cdots \oplus a_i-...]$，因为$a_i$后面的符合只能是加或减，有两种可能所以是乘二，对于$a_{i+1}$后面的符合都任意，后面有$n-i-1$个符号，所以乘$3^{n-i-1}$

当右端点为$n$时，后面没有符合了不适用于前面的公式了，但此时也只有全部异或这一种情况，这里单独特判即可
$$ans\leftarrow ans+{\oplus }_{i=1}^n{a}_i$$

代码

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

    std::vector<int> a(n + 1);
    for (int i = 1; i <= n; i++) std::cin >> a[i];

    i64 x = 0;
    Z ans = 0;
    for (int i = 1; i <= n; i ++) {
        x ^= a[i];
        if (i == n) ans += x;
        else ans += x * 2 * power(Z(3), n - i - 1);
    }

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