【十三届蓝桥杯】2022年蓝桥杯省赛个人解答 C++ B 组

又到了一年一度的蓝桥杯。尽管题目尽力去做了，临场感觉也不错，还是出现了各种疏漏。本文不保证正确性，相应地会注明已发现的不够妥当之处。答案仅为临场思考的扩充解释。

A: 九进制转十进制

​ 本题总分：5 分

【问题描述】

​ 九进制正整数 $(2022{)}_9$ 转换成十进制等于多少？

【答案提交】

​ 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

思路

手算。

// 1478

B: 顺子日期

​ 本题总分：5 分

【问题描述】

​ 小明特别喜欢顺子。顺子指的就是连续的三个数字：$123$、$456$ 等。顺子日期指的就是在日期的 yyyymmdd 表示法中，存在任意连续的三位数是一个顺子的日期。例如 $20220123$ 就是一个顺子日期，因为它出现了一个顺子：$123$； 而 $20221023$ 则不是一个顺子日期，它一个顺子也没有。小明想知道在整个 $2022$ 年份中，一共有多少个顺子日期。

【答案提交】

​ 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

思路

利用 for 循环枚举日期；将日期转化成字符串，判断顺子。

关于具体什么是顺子，题目说得不够明确。作者保留意见。

代码

#include <bits/stdc++.h>
using namespace std;
int dm[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
string tostring(int n) {
    string res = "";
    while (n) {
        res += (n % 10) + '0';
        n /= 10;
    }
    reverse(res.begin(), res.end());
    if (res.size() == 1) res = "0" + res;
    return res;
}
bool check(string s) {
    for (int i=2; i<s.size(); ++i) {
        if (s[i] == s[i - 1] + 1 && s[i - 1] == s[i - 2] + 1) {
            return true;
        }
    }
    return false;
}
int main() {
    string y = "2022";
    int ans = 0;
    for (int m=1; m<=12; ++m) {
        for (int d=1; d<=dm[m]; ++d) {
            string s = y + tostring(m) + tostring(d);
            if (check(s)) {
                cout << s << endl;
                ++ans;
            }
        }
    }
    cout << ans << endl;
    return 0;
}

输出

20220120
20220121
20220122
20220123
20220124
20220125
20220126
20220127
20220128
20220129
20221012
20221123
20221230
20221231
14

C: 刷题统计

​ 时间限制: 1.0s 内存限制: 256.0MB 本题总分：10 分

【问题描述】

​ 小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天做 $a$ 道题目，周六和周日每天做 $b$ 道题目。请你帮小明计算，按照计划他将在 第几天实现做题数大于等于 $n$ 题？

【输入格式】

​ 输入一行包含三个整数 $a$, $b$ 和 $n$.

【输出格式】

​ 输出一个整数代表天数。

【样例输入】

10 20 99 

【样例输出】

8

【评测用例规模与约定】

​ 对于 50% 的评测用例，$1\le a,b,n\le 10^6$ .

​ 对于 100% 的评测用例，$1\le a,b,n\le 10^{18}$ .

思路

每星期做题量为 $5a+2b$，剩下不足一周的，直接模拟加上去。

代码

#include <bits/stdc++.h>
#define int ll
using namespace std;
typedef long long ll;
int day;
int a, b, n;
signed main() {
    cin >> a >> b >> n;
    int ans = 0;
    int p = 5 * a + 2 * b;
    ans += 7 * (n / p);
    n %= p;
    while (n > 0) {
        ++ans;
        if (day == 5 || day == 6) n -= b;
        else n -= a;
        day = (day + 1) % 7;
    }
    cout << ans << endl;
    return 0;
}

D: 修剪灌木

​ 时间限制: 1.0s 内存限制: 256.0MB 本题总分：10 分

【问题描述】

​ 爱丽丝要完成一项修剪灌木的工作。

​ 有 $N$ 棵灌木整齐的从左到右排成一排。爱丽丝在每天傍晚会修剪一棵灌木，让灌木的高度变为 $0$ 厘米。爱丽丝修剪灌木的顺序是从最左侧的灌木开始， 每天向右修剪一棵灌木。当修剪了最右侧的灌木后，她会调转方向，下一天开始向左修剪灌木。直到修剪了最左的灌木后再次调转方向。然后如此循环往复。

​ 灌木每天从早上到傍晚会长高 $1$ 厘米，而其余时间不会长高。在第一天的早晨，所有灌木的高度都是 $0$ 厘米。爱丽丝想知道每棵灌木最高长到多高。

【输入格式】

一个正整数 $N$ ，含义如题面所述。

【输出格式】

​ 输出 $N$ 行，每行一个整数，第行表示从左到右第 $i$ 棵树最高能长到多高。

【样例输入】

3 

【样例输出】

4 2 4 

【评测用例规模与约定】

对于 30% 的数据，$N\le 10$.

对于 100% 的数据，$1<N\le 10000$.

思路

制作扩展样例，找规律。首项为 $2n-3+1$，每一项递减 $2$，答案整体回文，所以只推一半，判断长度奇偶，后一半直接反转前一半得到。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 4;
int s[N];
int n;
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> n;
    int mid = (n + 1) / 2;
    int a = 2 * n - 3;
    for (int i=1; i<=mid; ++i) {
        s[i] = a + 1;
        cout << s[i] << endl;
        a -= 2;
    }
    for (int i=mid; i>=1; --i) {
        if (i == mid && n & 1) continue;
        cout << s[i] << endl;
    }
    return 0;
}

E: X 进制减法

​ 时间限制: 1.0s 内存限制: 256.0MB 本题总分：15 分

【问题描述】

​ 进制规定了数字在数位上逢几进一。

​ $X$ 进制是一种很神奇的进制，因为其每一数位的进制并不固定！例如说某种 $X$ 进制数，最低数位为二进制，第二数位为十进制，第三数位为八进制，则 $X$ 进制数 $321$ 转换为十进制数为 $65$。

​ 现在有两个 $X$ 进制表示的整数 $A$ 和 $B$，但是其具体每一数位的进制还不确定，只知道 $A$ 和 $B$ 是同一进制规则，且每一数位最高为 $N$ 进制，最低为二进制。请你算出 $A-B$ 的结果最小可能是多少。

​ 请注意，你需要保证 $A$ 和 $B$ 在 $X$ 进制下都是合法的，即每一数位上的数字要小于其进制。

【输入格式】

​ 第一行一个正整数 $N$，含义如题面所述。

​ 第二行一个正整数 $M_a$，表示 X 进制数 $A$ 的位数。

​ 第三行 $M_a$ 个用空格分开的整数，表示 $X$ 进制数 $A$ 按从高位到低位顺序各个数位上的数字在十进制下的表示。

​ 第四行一个正整数 $M_b$，表示 $X$ 进制数 $B$ 的位数。

​ 第五行 $M_b$ 个用空格分开的整数，表示 $X$ 进制数 $B$ 按从高位到低位顺序各个数位上的数字在十进制下的表示。

​ 请注意，输入中的所有数字都是十进制的。

【输出格式】

​ 输出一行一个整数，表示 $X$ 进制数 $A-B$ 的结果的最小可能值转换为十进制后再模 $1000000007$ 的结果。

【样例输入】

11 3 10 4 0 3 1 2 0 

【样例输出】

94 

【样例说明】

当进制为：最低位 2 进制，第二数位 5 进制，第三数位 11 进制时，减法 得到的差最小。此时 A 在十进制下是 108，B 在十进制下是 14，差值是 94。

【评测用例规模与约定】

​ 对于 30% 的数据，$N\le 10;M_a,M_b\le 8$.

​ 对于 100% 的数据，$2\le N\le 1000;1\le M_a,M_b\le 100000;A\ge B$.

思路

题没读懂，试了很多次，凑不出问题描述中的 65。就没有再花时间。

F: 统计子矩阵

​ 时间限制: 1.0s 内存限制: 256.0MB 本题总分：15 分

【问题描述】

给定一个 $N\times M$ 的矩阵 $A$，请你统计有多少个子矩阵 (最小 $1\times 1$，最大 $N\times M$) 满足子矩阵中所有数的和不超过给定的整数 $K$?

【输入格式】

第一行包含三个整数 $N$, $M$ 和 $K$.

​ 之后 $N$ 行每行包含 $M$ 个整数，代表矩阵 $A$.

【输出格式】

一个整数代表答案。

【样例输入】

3 4 10 1 2 3 4 5 6 7 8 9 10 11 12

【样例输出】

19

【样例说明】

​ 满足条件的子矩阵一共有 $19$，包含：

​ 大小为 $1\times 1$ 的有 $10$ 个。
​ 大小为 $1\times 2$ 的有 $3$ 个。
​ 大小为 $1\times 3$ 的有 $2$ 个。
​ 大小为 $1\times 4$ 的有 $1$ 个。
​ 大小为 $2\times 1$ 的有 $3$ 个。

【评测用例规模与约定】

​ 对于 30% 的数据，$N,M\le 20$.

​ 对于 70% 的数据，$N,M\le 100$.

​ 对于 100% 的数据，$1\le N,M\le 500;0\le A_{ij}\le 1000;1\le K\le 250000000$.

思路

前缀和模板题。

注意：理论上朴素前缀和，在100%的数据上会超时。记得在力扣上有类似的矩阵题，可以降低复杂度。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 504;
ll a[N][N];
ll n, m, k;
int main() {
    cin >> n >> m >> k;
    for (int i=1; i<=n; ++i) {
        for (int j=1; j<=m; ++j) {
            cin >> a[i][j];
            a[i][j] += a[i-1][j] + a[i][j-1] - a[i-1][j-1];
        }
    }
    ll ans = 0;
    for (int x1=1; x1<=n; ++x1) {
        for (int y1=1; y1<=m; ++y1) {
            for (int x2=x1; x2<=n; ++x2) {
                for (int y2=y1; y2<=m; ++y2) {
                    ll res = a[x2][y2] - a[x1-1][y2] - a[x2][y1-1] + a[x1-1][y1-1];
                    if (res <= k) ++ans;
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}

G: 积木画

时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分

【问题描述】

​ 小明最近迷上了积木画，有这么两种类型的积木，分别为 $I$ 型（大小为 $2$ 个单位面积）和 $L$ 型（大小为 $3$ 个单位面积）：

同时，小明有一块面积大小为 $2\times N$ 的画布，画布由 $2\times N个1\times 1$ 区域构成。小明需要用以上两种积木将画布拼满，他想知道总共有多少种不同的方式？ 积木可以任意旋转，且画布的方向固定。

【输入格式】

​ 输入一个整数 $N$，表示画布大小。

【输出格式】

​ 输出一个整数表示答案。由于答案可能很大，所以输出其对 $1000000007$ 取模后的值

【样例输入】

3 

【样例输出】

5

【样例说明】

​ 五种情况如下图所示，颜色只是为了标识不同的积木：

【评测用例规模与约定】

​ 对于所有测试用例，$1\le N\le 10000000$.

思路

注意：此题的考虑不完全，答案不正确。下第 2、3 种情况可能交叉出现，即情况 3、4 中的两个三角块之间，可以填入情况 2 的横条块。

典型动态规划问题。我的思路是，定义状态 dp[i] 为拼满前 $2\times i$ 大小的方案数。由于定义为「拼满」，有以下 $4$ 种转移：

将每种转移状态的方案数相加即可。

代码

#include <bits/stdc++.h>
#define int ll
using namespace std;
typedef long long ll;
const int N = 1e7 + 4, mod = 1000000007;
int dp[N];
int n;
signed main() {
    cin >> n;
    dp[0] = 1;
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 5;
    for (int i=3; i<=n; ++i) {
        dp[i] = dp[i - 1];
        dp[i] = (dp[i] + dp[i - 2]) % mod;
        dp[i] = (dp[i] + (dp[i - 3] * 2) % mod) % mod;
    }
    //for (int i=0; i<n; ++i) cout << i << ','<<dp[i] << endl;
    cout << dp[n] << endl;
    return 0;
}
// dp

H: 扫雷

​ 时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分

【问题描述】

小明最近迷上了一款名为《扫雷》的游戏。其中有一个关卡的任务如下， 在一个二维平面上放置着 $n$ 个炸雷，第 $i$ 个炸雷 $(x_i,y_i,r_i)$ 表示在坐标 $(x_i,y_i)$ 处 存在一个炸雷，它的爆炸范围是以半径为 $r_i$ 的一个圆。

为了顺利通过这片土地，需要玩家进行排雷。玩家可以发射 $m$ 个排雷火箭，小明已经规划好了每个排雷火箭的发射方向，第 j 个排雷火箭 $(x_j,y_j,r_j)$ 表 示这个排雷火箭将会在 $(x_j,y_j)$ 处爆炸，它的爆炸范围是以半径为 $r_j$ 的一个圆， 在其爆炸范围内的炸雷会被引爆。同时，当炸雷被引爆时，在其爆炸范围内的 炸雷也会被引爆。现在小明想知道他这次共引爆了几颗炸雷？

你可以把炸雷和排雷火箭都视为平面上的一个点。一个点处可以存在多个炸雷和排雷火箭。当炸雷位于爆炸范围的边界上时也会被引爆。

【输入格式】

输入的第一行包含两个整数 $n$、$m$.

​ 接下来的 $n$ 行，每行三个整数 $x_i,y_i,r_i$，表示一个炸雷的信息。

​ 再接下来的 $m$ 行，每行三个整数 $x_j,y_j,r_j$，表示一个排雷火箭的信息。

【输出格式】

输出一个整数表示答案。

【样例输入】

2 1
2 2 4
4 4 2
0 0 5

【样例输出】

2 

【样例说明】

​ 示例图如下，排雷火箭 1 覆盖了炸雷 1，所以炸雷 1 被排除；炸雷 1 又覆 盖了炸雷 2，所以炸雷 2 也被排除。

【评测用例规模与约定】

​ 对于 40% 的评测用例：$0\le x,y\le 10^9,0\le n,m\le 10^3,1\le r\le 10.$

​ 对于 100% 的评测用例：$0\le x,y\le 10^9,0\le n,m\le 5\times 10^4,1\le r\le 10.$

思路

时间有限，没想到好的办法，于是暴力模拟。

地雷、火箭共用 C (circle) 类型。 boom() 函数递归实现地雷的引爆。

后话：也许可以建图，在可以连续引爆的地雷之间建立有向边，比直接暴力搜索高效得多。

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 5e4 + 4;
struct C {
    int x, y, r;
    void read() {
        cin >> x >> y >> r;
    }
};
C mines[N];
bool vis[N];    // mine valid
C rockets[N];
int n, m;
int ans;
double dist(C u, C v) {
    double dx = v.x - u.x, dy = v.y - u.y;
    return sqrt(dx*dx + dy*dy);
}
bool co(C u, C v) {
    return dist(u, v) < u.r + v.r;
}
void boom(C bomb) {
    for (int i=0; i<n; ++i) {
        C mine = mines[i];
        if (vis[i]) continue;
        if (co(mine, bomb)) {
            ++ans;
            vis[i] = true;
            boom(mine);
        }
    }
}
int main() {
    cin >> n >> m;
    for (int i=0; i<n; ++i) mines[i].read();
    for (int i=0; i<m; ++i) rockets[i].read();
    for (int i=0; i<m; ++i) {
        boom(rockets[i]);
    }
    cout << ans << endl;
    return 0;
}

I: 李白打酒加强版

时间限制: 1.0s 内存限制: 256.0MB 本题总分：25 分

【问题描述】

​ 话说大诗人李白，一生好饮。幸好他从不开车。

​ 一天，他提着酒壶，从家里出来，酒壶中有酒 $2$ 斗。他边走边唱：

​ 无事街上走，提壶去打酒。
​ 逢店加一倍，遇花喝一斗。

​ 这一路上，他一共遇到店 $N$ 次，遇到花 $M$ 次。已知最后一次遇到的是花， 他正好把酒喝光了。 请你计算李白这一路遇到店和花的顺序，有多少种不同的可能？

​ 注意：壶里没酒 ( $0$ 斗) 时遇店是合法的，加倍后还是没酒；但是没酒时遇花是不合法的。

【输入格式】

​ 第一行包含两个整数 $N$ 和 $M$.

【输出格式】

输出一个整数表示答案。由于答案可能很大，输出模 $1000000007$ 的结果。

【样例输入】

5 10 

【样例输出】

14 

【样例说明】

​ 如果我们用 $0$ 代表遇到花，$1$ 代表遇到店，$14$ 种顺序如下：

​ 010101101000000
​ 010110010010000
​ 011000110010000
​ 100010110010000
​ 011001000110000
​ 100011000110000
​ 100100010110000
​ 010110100000100
​ 011001001000100
​ 100011001000100
​ 100100011000100
​ 011010000010100
​ 100100100010100
​ 101000001010100

【评测用例规模与约定】

对于 40% 的评测用例：$1\le N,M\le 10$。

对于 100% 的评测用例：$1\le N,M\le 100$。

思路

再次很典型的 DP 问题，需要三个维度。dp[i][j][k] 表示遇到 $i$ 次店、$j$ 次花，恰有酒 $k$ 斗的方案数。显然，有两种转移：

1. 上一次遇到花，喝掉了一斗酒 （dp[i][j - 1][k + 1]）
2. 上一次遇到店，添了一倍的酒 （dp[i - 1][j][k / 2]， $k$ 为偶数）

由于最后一次必须遇到花，我们不直接计算答案 dp[n][m][0]，而计算 dp[n][m - 1][1]，也就是预留一朵花，只关心直到倒数第二站的情况。

虽然题中 $k$ 取值没有过多限制，我们考虑状态计算的范围就好，毕竟遇到 1 次花才能喝 1 次酒，喝不完就不合法了。

一点小难点：起始的边界条件需要花点时间写出来。

#include <bits/stdc++.h>
#define int ll
using namespace std;
typedef long long ll;
const int N = 104;
const int mod = 1000000007;
int dp[N][N][N + 10];
int n, m;
signed main() {
    cin >> n >> m;
    --m;
    // i==0 && j==0
    dp[0][0][2] = 1;   
    // j==0
    for (int i=1; i<=n; ++i)
    	for (int k=0; k<=m + 4; ++k)
    		if (k % 2 ==0)
        		dp[i][0][k] += dp[i-1][0][k/2];
    // i==0
    dp[0][1][1] = 1;
    dp[0][2][0] = 1;
    for (int i=1; i<=n; ++i) {
    	for (int j=1; j<=m; ++j) {
    		for (int k=0; k<=m + 4; ++k) {
        		dp[i][j][k] = (dp[i][j][k] + dp[i][j-1][k+1])%mod; // f
        		if (k%2==0)
                    dp[i][j][k] = (dp[i][j][k] + dp[i-1][j][k/2])%mod;// s
    		}
    	}
    }
    cout << dp[n][m][1] << endl;
    return 0;
}

J: 砍竹子

​ 时间限制: 1.0s 内存限制: 256.0MB 本题总分：25 分

【问题描述】

​ 这天，小明在砍竹子，他面前有 $n$ 棵竹子排成一排，一开始第 $i$ 棵竹子的 高度为 $h_i$ .

​ 他觉得一棵一棵砍太慢了，决定使用魔法来砍竹子。魔法可以对连续的一 段相同高度的竹子使用，假设这一段竹子的高度为 $H$，那么使用一次魔法可以 把这一段竹子的高度都变为 $\lfloor \sqrt{\lfloor \frac{H}{2}\rfloor +1}\rfloor$，其中 $\lfloor x\rfloor$ 表示对 $x$ 向下取整。小明想 知道他最少使用多少次魔法可以让所有的竹子的高度都变为 $1$。

【输入格式】

​ 第一行为一个正整数 $n$，表示竹子的棵数。

​ 第二行共 n 个空格分开的正整数 $h_i$，表示每棵竹子的高度。

【输出格式】

​ 一个整数表示答案。

【样例输入】

6 2 1 4 2 6 7 

【样例输出】

5 

【样例说明】

其中一种方案：

​ 2 1 4 2 6 7

​ → 2 1 4 2 6 2

​ → 2 1 4 2 2 2

​ → 2 1 1 2 2 2

​ → 1 1 1 2 2 2

​ → 1 1 1 1 1 1

​ 共需要 5 步完成

【评测用例规模与约定】

对于 20% 的数据，保证 $n\le 1000,h_i\le 10^6$。

对于 100% 的数据，保证 $n\le 2\times 10^5,h_i\le 10^{18}$。

思路

优先做前面的题，没做出来。

赛后感言

至少是此次的蓝桥杯，暴力和搜索已经不是一个主题。我想，就像是我愿意相信在一个人的身上蕴藏着无限的可能性，蓝桥杯也不会永远是那个蓝桥杯。今天，赛题作为事实有力地说明了，此比赛在多种信息学竞赛之中，不是后继的模仿者，而具有脱俗的表现和别致的魄力，不仅要求选手写出代码，而且深刻地考察不限于阅读理解、压力测试等多方面能力。从坚持不支持 to_string() 的古典编译器，到评测机到底给了几分这一神秘的不解之谜，我想，我们可以暂时忘掉世俗的意见，记起算法本身的乐趣。

所谓「友谊第一，比赛第二」。我觉得，不只是友谊，关注第一性的方面更加重要。我喜欢算法，不仅仅是因为比赛。我也希望着，比赛的形式，能够真正有效地发挥促学励学的作用。最后，祝各位身体健康。