文章目录

蓝桥杯2022年B组初赛题解C++
- A题：九进制转十进制
- B题：顺子日期
- C题：刷题统计
- D题：修剪灌木
- E题：X进制减法
- F题：统计子矩阵
- G题：积木画
- H题：扫雷
- I题：李白打酒加酒加强版
- J题：砍竹子

蓝桥杯2022年B组初赛题解C++

A题：九进制转十进制

题面： 九进制正整数(2022) 转换成十进制等于多少？这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只输出这个整数，输出多余的内容将无法得分。
知识点：不同进制数（整数）之间的转化
分析： 从右到左各位数乘以9的n-1次方求和即可（其中n为从右向左数第n个数），所以：2∗90+2∗91+0∗92+2∗93=14782*9^0+2*9^1+0*9^2+2*9^3=14782∗90+2∗91+0∗92+2∗93=1478
代码如下：

#include<iostream>
using namespace std;
int main()
{printf("1478");return 0;
}

B题：顺子日期

题面： 小明特别喜欢顺子。顺子指的就是连续的三个数字：123、456 等。顺子日期指的就是在日期的 yyyymmdd 表示法中，存在任意连续的三位数是一个顺子的日期。例如20220123 就是一个顺子日期，因为它出现了一个顺子：123；本题顺子的定义：i j k 是一个顺子，满足 i+1=j、j+1=k、i≥0。 而20221023 则不是一个顺子日期，它一个顺子也没有。小明想知道在整个2022年份中，一共有多少个顺子日期。这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只输出这个整数，输出多余的内容将无法得分。
知识点：手动枚举
分析： 首先明确yyyymmdd是年月日的意思（废话），然后顺子的定义为连续且递增的三个数字。然后，从头开始枚举（不容易出错）。PS：注意这题的2022年首先不是闰年，其次不含顺子，这使得我们考虑时无需考虑年份（和月份连不成顺子)以及二月可能存在的特殊情况（虽然二月本身就不影响这题的答案）
下面开始列举月份（共14个）：
0120
0121
0122
0123
0124
0125
0126
0127
0128
0129
1012
1123
1230
1231
代码如下：

#include<iostream>
using namespace std;
int main()
{printf("14");return 0;
}

C题：刷题统计

题面： 小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天做 a 道题目，周六和周日每天做 b 道题目。请你帮小明计算，按照计划他将在 第几天实现做题数大于等于 n 题？
输入格式：
输入一行包含三个整数a, b 和n.
50% 的评测用例：1 ≤ a, b, n ≤ 10^6；
100% 的评测用例：1 ≤ a, b, n ≤ 10^18。
输出格式：
输出一个整数代表天数。
知识点：除法、取模、细心
分析： 从周开始计数，然后依次是周一到周五、周六周日，不断缩小范围。这题难度不大，但要 细心一点（至少我的做法是这样），具体细节直接看代码
代码如下：

#include<iostream>
using namespace std;
typedef long long ll;
int main()
{ll a,b,n;//数据范围为10的18次方 scanf("%lld%lld%lld",&a,&b,&n);ll t,ans=0;//t为做题量，ans为答案 t=a*5+b*2;//一周的做题量ans+=n/t*7;///求多少周 n%=t;//剩下题量 if(n)//题量不为0 {t=5*a;//周一到周五的做题量if(n>t){//周六周日 n-=t;//注意不能取模（想想看为什么）ans+=5;//加五天 t=b; ans+=n/t;n%=t;if(n){ans++;}}else{//周一到周五 t=a;//可以直接用a，防止混乱吧 ans+=n/t;n%=t;if(n){ans++;} }} printf("%lld",ans);return 0;
}

D题：修剪灌木

题面： 爱丽丝要完成一项修剪灌木的工作。有 N 棵灌木整齐的从左到右排成一排。爱丽丝在每天傍晚会修剪一棵灌木，让灌木的高度变为 0 厘米。爱丽丝修剪灌木的顺序是从最左侧的灌木开始，每天向右修剪一棵灌木。当修剪了最右侧的灌木后，她会调转方向，下一天开始向左修剪灌木。直到修剪了最左的灌木后再次调转方向。然后如此循环往复。灌木每天从早上到傍晚会长高 1 厘米，而其余时间不会长高。在第一天的早晨，所有灌木的高度都是 0 厘米。爱丽丝想知道每棵灌木最高长到多高。
输入格式：
一个正整数N ，含义如题面所述。
30%的测试数据：1<N≤10；
100%的测试数据：1<N≤10000。
输出格式：
输出 N 行，每行一个整数，第 i 行表示从左到右第 i 棵树最高能长到多高。
知识点：找规律
分析： 我们观察到修剪灌木到端点会调转方向，并且是一个循环往复的过程，那么我们就可以选取局部来代替整体，而且我们可以将这个局部过程抽象为一个环形结构
画图分析：

这里的局部为修剪来回共三次，这时无论是偏左还是偏右的灌木都已经长到过最高。抽象成环形结构之后偏左灌木的生长周期（即高度）为绿线长度，偏右灌木的生长周期为红线长度。
进行公式推导（对于每个灌木，其位置为i，总共灌木数为n）：
偏左（将中间位置归于偏左，否则n为奇数时容易出错）：2∗(n−i)2*(n-i)2∗(n−i)
偏右：2∗(i−1)2*(i-1)2∗(i−1)
公式推出来之后，就是用数组模拟求解。
代码如下：

#include<iostream>
using namespace std;
const int N=10010;
int tree[N];//int就够了
int main()
{int n;scanf("%d",&n);for(int i=1;i<=n;i++){if(i<=n/2){tree[i]=2*(n-i);}else{tree[i]=2*(i-1);}}for(int i=1;i<=n;i++){printf("%d\n",tree[i]);}return 0;
}

E题：X进制减法

题面： 进制规定了数字在数位上逢几进一。X 进制是一种很神奇的进制，因为其每一数位的进制并不固定！例如说某种X 进制数，最低数位为二进制，第二数位为十进制，第三数位为八进制：则 X 进制数321 转换为十进制数为65。65=3*(210)+2(2)+1*(1)。现在有两个 X 进制表示的整数 A 和 B，但是其具体每一数位的进制还不确定。只知道 A 和 B 是同一进制规则，且每一数位最高为 N 进制，最低为二进制。请你算出 A − B 的结果最小可能是多少。请注意，你需要保证 A 和 B 在 X 进制下都是合法的，即每一数位上的数字要小于其进制。
输入格式：
第一行一个正整数 N，含义如题面所述。
第二行一个正整数 Ma，表示 X 进制数 A 的位数。
第三行 Ma 个用空格分开的整数，表示 X 进制数 A 按从高位到低位顺序各个数位上的数字在十进制下的表示。
第四行一个正整数 Mb，表示 X 进制数 B 的位数。
第五行 Mb 个用空格分开的整数，表示 X 进制数 B 按从高位到低位顺序各个数位上的数字在十进制下的表示。
请注意，输入中的所有数字都是十进制的。
30%的测试数据：2≤N≤10,1≤Ma,Mb≤8。
100%的测试数据：2≤N≤1000,1≤Ma,Mb≤100000，B≤A。
输出格式：
输出一行一个整数，表示X 进制数A − B 的结果的最小可能值转换为十进制后再模1000000007 的结果。
知识点：理解题意、贪心、数位对齐
分析： 首先要理解题意，尤其是进制会对什么产生影响。实际上，这里的进制影响的是下一个数位，因为下一个数位是由这一位上的数进位得到的，进制影响的是满几进一，也就是下一数位上的数所对应的大小，当然，同时也影响了下下数位…我们就得到了将X进制数转换为十进制的方法。因为A与B的进制相同，所以想要得到A-B的差值，我们只需要将每个数位相减（A-B），再根据进制数转化为十进制即可。那么想要使差值最小，只要进制数尽可能的小就行（转化见A题），这就是一种贪心的思想
代码如下：

#include<iostream>
using namespace std;
const int N=100010,M=1000000007;
typedef long long ll;
ll a[N],b[N],jz[N];//jz数组表进制（英文不会）
int main()
{ll n,ans=0;scanf("%lld",&n);//这里的n一定合理，所以不用管 ll ma,mb;scanf("%lld",&ma);for(int i=ma;i>=1;i--){//注意输入，倒序输入可使数位对齐，也好遍历 scanf("%lld",&a[i]);}scanf("%lld",&mb);for(int i=mb;i>=1;i--){scanf("%lld",&b[i]);}for(int i=1;i<=ma;i++){//注意A是大于等于B的 jz[i]=max(a[i],b[i])+1;if(jz[i]<2){//最低是二进制 jz[i]=2;}a[i]-=b[i];//先将差值处理好 }for(int i=ma;i>=1;i--){//这种方法可以防止乘积过大 ans=(ans*jz[i]+a[i])%M;}printf("%lld",ans);return 0;
}

F题：统计子矩阵

题面： 给定一个 N × M 的矩阵A，请你统计有多少个子矩阵(最小 1 × 1，最大 N × M) 满足：
子矩阵中所有数的和不超过给定的整数K?
输入格式：
第一行包含三个整数N, M 和K.
之后 N 行每行包含 M 个整数，代表矩阵A.
30%的测试数据：1≤N,M≤20；
70%的测试数据：1≤N,M≤100；
100%的测试数据：1≤N,M≤500；0≤Aij≤1000；1≤K≤250000000。
输出格式：
一个整数代表答案。
知识点：二维前缀和、双指针算法
分析： 该题最初步的想法是二维前缀和优化，这很容易想到，但我们发现，想要遍历所有的子矩阵，时间复杂度是O(n4n^4n4)的，也就是10的10次方左右，显然，这超时了。所以我们换一种方式，利用双指针的方式进行再次优化，将时间复杂度降到O(n3n^3n3)，也就是10的8次方左右，可以AC。
画图分析：

这样四个位置就可以确定一个子矩阵，我们通过l和r对列进行遍历，并且不是在最坏的情况下我们并不需要遍历所有列**（这是因为在l不动r向右平移时子矩阵的和是单调递增，所以只要找到第一大于k的情况即可）**,接着我们改变行指针就可完成所有子矩阵的遍历。
代码如下：

#include<iostream>
using namespace std;
const int N=510;
int a[N][N],s[N][N];//s数组为前缀和数组
long long sum(int i,int l,int j,int r)//防止爆int
{return s[j][r]-s[i-1][r]-s[j][l-1]+s[i-1][l-1];//这个如果不明白可以去前面双指针的图上去画一画
}
int main()
{int n,m,k;long long ans=0;//数据可能比较大 scanf("%d%d%d",&n,&m,&k);for(int i=1;i<=n;i++){//这边前缀和处理行列要从1开始，防止越界 for(int j=1;j<=m;j++){scanf("%d",&a[i][j]);s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];}}for(int i=1;i<=n;i++){for(int j=i;j<=n;j++){for(int l=1,r=1;r<=m;r++){while(l<=r&&sum(i,l,j,r)>k){l++;}ans+=r-l+1;//每次加上满足条件的列数 }}}printf("%lld",ans);
}

G题：积木画

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

同时，小明有一块面积大小为 2 × N 的画布，画布由 2 × N 个 1 × 1 区域构成。
小明需要用以上两种积木将画布拼满，他想知道总共有多少种不同的方式？
积木可以任意旋转，且画布的方向固定。
输入格式：
输入一个整数N，表示画布大小。
对于所有测试用例，1 ≤ N ≤ 10000000。
输出格式：
输出一个整数表示答案。由于答案可能很大，所以输出其对 1000000007 取模后的值。
知识点：递推关系（动态规划）
**分析：**这道题是道很经典的题，我们观察题面可以发现，只有两种积木可以组合，我们按列往下分析，可以发现，想要铺满每列，组合的方式是有限的，即使长度很长，我们也可以由之前的状态可能推出现在的状态可能。这题既可以用动态规划去做，也可以求出i列方法总数的递推关系，再由前几列方法总数递推出后面列的答案。我们在这里用第二种方法进行分析。
画图分析：
我们约定：f[i]表示i列的方法总数
1.在前i-1列铺满的情况下，f[i]=f[i-1]
2.在前i-2列铺满的情况下，f[i]=f[i-1]+f[i-2]（我们在这排除了重复的情况，以下同理）

3.在前i-3列铺满的情况下，f[i]=f[i-1]+f[i-2]+2f[i-3]

4.在前i-4列铺满的情况下，f[i]=f[i-1]+f[i-2]+2f[i-3]+2*f[i-4]

终于，我们列举完了所有的 基本情况 ，列举完了，实际并没有，但我们已经可以根据以上的基本情况推出之后所有的项，具体来说，我们只需要在3和4的基础上在L型积木块之间填充横向的I型积木块就可以推出之后所有的前奇数偶数列铺满的情况（每个都是加2*f[i-j]种，j是前i-j列），3对应奇数，4对应偶数，每个加2嘛。
有了这样一个长的递推公式，我们进行化简：

(画的很丑，但至少画出来了…)
接下来，就是代码实现，我们由f[1]=1,f[2]=2,f[3]=5，得出如下代码：

#include<iostream>
using namespace std;
const int N=10000010,M=1000000007;
int f[N];
int main()
{int n;scanf("%d",&n);f[1]=1;f[2]=2;f[3]=5;for(int i=4;i<=n;i++){f[i]=(2*f[i-1]%M+f[i-3]%M)%M;//注意不要直接对整体取模，会爆int }printf("%d",f[n]);
}

H题：扫雷

题面： 小明最近迷上了一款名为《扫雷》的游戏。其中有一个关卡的任务如下，在一个二维平面上放置着 n 个炸雷，第 i 个炸雷(xi, yi, ri) 表示在坐标(xi, yi) 处存在一个炸雷，它的爆炸范围是以半径为 ri 的一个圆。为了顺利通过这片土地，需要玩家进行排雷。玩家可以发射 m 个排雷火箭，小明已经规划好了每个排雷火箭的发射方向。第 j 个排雷火箭(xj, yj, rj) 表示这个排雷火箭将会在(xj, yj) 处爆炸，它的爆炸范围是以半径为 rj 的一个圆，在其爆炸范围内的炸雷会被引爆。同时，当炸雷被引爆时，在其爆炸范围内的炸雷也会被引爆。现在小明想知道他这次共引爆了几颗炸雷？你可以把炸雷和排雷火箭都视为平面上的一个点。一个点处可以存在多个炸雷和排雷火箭。当炸雷位于爆炸范围的边界上时也会被引爆。
输入格式：
输入的第一行包含两个整数n、m.
接下来的 n 行，每行三个整数xi, yi, ri，表示一个炸雷的信息。
再接下来的 m 行，每行三个整数xj, yj, rj，表示一个排雷火箭的信息。
40% 的评测用例：0 ≤ x, y ≤ 10910^9109; 0 ≤ n,m ≤ 10310^3103; 1 ≤ r ≤ 10:
100% 的评测用例：0 ≤ x, y ≤ 10910^9109; 0 ≤ n,m ≤ 5×1045 × 10^45×104; 1 ≤ r ≤ 10:
输出格式：
输出一个整数表示答案。
知识点：哈希、有向图、搜索
分析：（待完善）

I题：李白打酒加酒加强版

题面： 话说大诗人李白，一生好饮。幸好他从不开车 （喝酒不开车）。一天，他提着酒壶，从家里出来，酒壶中有酒 2 斗。他边走边唱：
无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店 N 次，遇到花 M 次。已知最后一次遇到的是花，他正好把酒喝光了。
请你计算李白这一路遇到店和花的顺序，有多少种不同的可能？
注意：壶里没酒( 0 斗) 时遇店是合法的，加倍后还是没酒；但是没酒时遇花是不合法的。
输入格式：
输入包含多组测试数据。
第一行为T，表示存在T组测试数据，T不超过30。
对于每组测试数据，输入两个整数N 和M.
1 ≤ N, M ≤ 100。
输出格式：
输出一个整数表示答案。由于答案可能很大，输出模1000000007 的结果。
知识点：动态规划
分析： 这道题目我们采取动态规划的方法来做，我们的已知条件有遇店N次，遇花M次，酒随着遇到店和花变化，求可能数。已知条件作为dp数组的限定条件，可能数作为dp数组的值。综上，dp数组是三维的，这里方法比较多，我们在这里约定：dp[i][j][k]中i表示当前遇到店和花的总次数，j表示遇到花的总次数，k表示壶里剩的酒的量。
接下来就是推dp数组的状态转移方程：
这里先给出几点注意事项：
1.最开始的状态：dp[0][0][2]=1
2.当壶里剩的酒的量k为偶数时，上一次遇到的可以是店；当壶里剩的酒的量k为奇数时，上一次遇到的不可以是店（因为无论奇数还是偶数的两倍都是偶数）
3.壶里剩的酒的量k不能大于M（不然全遇到花也喝不完）
4.因为最后遇到的一定是花，所以答案是dp[m+n-1][m-1][1]

代码如下：

#include<iostream>
#include<string.h>
using namespace std;
const int N=110,M=1000000007;
long long dp[2*N][N][N];//注意这里的数组大小
int main()
{int t;scanf("%d",&t);while(t--){memset(dp,0,sizeof(dp));//一定要初始化（因为有多个测试）！ int n,m;scanf("%d%d",&n,&m);dp[0][0][2]=1;for(int i=1;i<n+m;i++){//注意这里循环的初始和结束条件，想想为什么 for(int j=0;j<m;j++){for(int k=0;k<=m;k++){//这边根据判断条件对状态方程进行了修改，但本质不变 if(k%2==0){//这边只加了店的情况 dp[i][j][k]=(dp[i][j][k]+dp[i-1][j][k/2])%M; } if(j>0){//因为j是从零开始的，可能导致越界，进行一个判断 dp[i][j][k]=(dp[i][j][k]+dp[i-1][j-1][k+1])%M;//只加花的情况 }}}}printf("%lld\n",dp[m+n-1][m-1][1]);}return 0;
}

J题：砍竹子

题面： 这天，小明在砍竹子，他面前有 n 棵竹子排成一排，一开始第 i 棵竹子的高度为 hi。他觉得一棵一棵砍太慢了，决定使用魔法来砍竹子。魔法可以对连续的一段相同高度的竹子使用，假设这一段竹子的高度为H，那么使用一次魔法可以把这一段竹子的高度都变为：

其中 ⌊x⌋ 表示对 x 向下取整。小明想知道他最少使用多少次魔法可以让所有的竹子的高度都变为1。
输入格式：
第一行为一个正整数 n，表示竹子的棵数。
第二行共 n 个空格分开的正整数 hi，表示每棵竹子的高度。
20%的测试数据：n ≤ 1000; hi ≤ 10^6。
100%的测试数据：n ≤ 2 × 10^5; hi ≤ 10^18。
输出格式：
一个整数表示答案。
知识点：贪心，优先队列，结构体排序（重载小于号）
分析：~~有魔法用来砍竹子？~~注意，我们的任务是将所有竹子的高度全部变成1，魔法是对一段连续的相同高度的柱子使用，一次砍一半的开根号左右（这不重要），重要的是砍掉的高度与柱子本身的高度成正相关，也就是竹子越高，魔法的效果越好，那么这就是一种贪心的思想：我们每次砍掉最高的那一片竹子。好了，关键词是最高，那一片。所以我们用优先队列进行排序（这是比较妙的，每次出堆都是高度相同的），每次放回，并用结构体存高度和编号，注意放进优先队列要注意排序方法，这里我们先重载小于号。
代码如下：

#include<iostream>
#include<queue>
#include<cmath>
using namespace std;
typedef long long ll;//注意一下数据范围
struct bamboo{ll h;int num;bool operator <(const bamboo &a) const//重载小于号 {if(h==a.h){return num>a.num;//编号从小到大 } return h<a.h;}
};
priority_queue<bamboo> q;//大根堆
int main()
{int n,ans=0;//这个答案实际是很小的ll t1,t2;//临时存一下 scanf("%d",&n);for(int i=1;i<=n;i++){//i作为编号 scanf("%lld",&t1);q.push((bamboo){t1,i}); } while(q.top().h!=1)//当最高的竹子高度不为1时 {t1=q.top().h;t2=q.top().num;while(q.top().h==t1&&q.top().num==t2){q.pop();q.push((bamboo){sqrt(t1/2+1),t2});t2++;//这个要放在最后 }ans++;}printf("%d",ans);return 0;
}

参考文章：
F题： http://t.csdn.cn/HJeTq
G题： http://t.csdn.cn/qw9U3