第十三届蓝桥杯C++B组答案

目录

第一题：九进制转为十进制

第二题：顺子日期

第三题：刷题统计

第四题：修剪灌木

第五题：X 进制减法

第六题：统计子矩阵

第七题：积木画

第八题：扫雷

第九题：李白打酒加强版

第十题：砍竹子

---

第一题：九进制转为十进制

#include
#include
using namespace std;

int main(){
	/*
	k进制转为十进制： (2022)9-> 2*9^3 + 0*9^2 + 2*9^1 + 2*9^0 = 1478
	*/
	cout<<2*9*9*9 + 0*9*9 + 2*9 + 2*1< 2进制
	*/
	int n=8,k=2;
	vector v;
	while(n){
		v.push_back(n%k);
		n/=k;
	}
	// 倒叙输出就是答案
	for(int i=v.size()-1;i>=0;i--) cout<

第二题：顺子日期

 思路：枚举2022的所有天，将每一天转换为一个日期字符串，判断该字符串是否符合要求即可。

#include
#include
using namespace std;
int months[] = {0,31,28,31,30,31,30,31,31,30,31,30,31}; // 平年每月的天数
bool check(string str){
	for(int i=0;i+2months[month]){
			// 如果天数大于该月的天数
			day=1; // 天数置为1
			month++; // 月份++
		}

	}
	cout<

第三题：刷题统计

小明决定从下周一开始努力刷题准备蓝桥杯竞赛。

他计划周一至周五每天做 a 道题目，周六和周日每天做 b 道题目。

请你帮小明计算，按照计划他将在第几天实现做题数大于等于 n 题？

输入格式

输入一行包含三个整数a,b 和 n。

输出格式

输出一个整数代表天数。

数据范围

对于 50%的评测用例 ， 1≤a,b,n≤10e6，
对于 100%的评测用例，1≤a,b,n≤10e18。

输入样例：

10 20 99

输出样例：

8

思路：直接暴力枚举的化会超时，我们可以算一下小明一周可以做的题目之和为：sum=5*a+2*b，然后用 n/sum 看一看有多少个整周，剩下没有完成的题目数量为：n%sum,就不到一周了，直接枚举即可。

#include 
#include 
#include 
using namespace std;
typedef long long LL;

int main(){
    LL a,b,n;
    cin>>a>>b>>n;
    LL sum=5*a+2*b;
    LL res=n/sum*7;
    n%=sum;
    LL d[]={a,a,a,a,a,b,b};
    for(int i=0;n>0;i++){
        n-=d[i];
        res++;
    }
    cout<

第四题：修剪灌木

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

有 N 棵灌木整齐的从左到右排成一排。

爱丽丝在每天傍晚会修剪一棵灌木，让灌木的高度变为 0 厘米。

爱丽丝修剪灌木的顺序是从最左侧的灌木开始，每天向右修剪一棵灌木。

当修剪了最右侧的灌木后，她会调转方向，下一天开始向左修剪灌木。

直到修剪了最左的灌木后再次调转方向。

然后如此循环往复。

灌木每天从早上到傍晚会长高 1 厘米，而其余时间不会长高。

在第一天的早晨，所有灌木的高度都是 0 厘米。爱丽丝想知道每棵灌木最高长到多高。

输入格式

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

输出格式

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

数据范围

对于 30% 的数据，N≤10，
对于 100% 的数据，1

输入样例：

3

输出样例：

4
2
4

思路：注意灌木是先长高 1 厘米然后被剪到 0 厘米，

每棵树的最大高度取决于该数第一次被剪，到下一次被剪中间间隔多少天。

如果往左走：从 i 走到 n ，一共有 ( n - i ) 天，再从 n 走到 i  ,一共有 ( n - i ) 天，则最高为：2 * ( n - i ) 天.

如果从右往左走：最高为：2 * ( i - 1 ) 天 .

则最大值为  max ( 2 * ( n - i ) , 2 * ( i - 1 ) ) .

#include 
#include 
#include 
using namespace std;
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cout<

第五题：X 进制减法

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

X 进制是一种很神奇的进制，因为其每一数位的进制并不固定！

例如说某种 X 进制数，最低数位为二进制，第二数位为十进制，第三数位为八进制，则 X 进制数 321 转换为十进制数为 65。

现在有两个 X 进制表示的整数 A 和 B，但是其具体每一数位的进制还不确定，只知道 A 和 B 是同一进制规则，且每一数位最高为 N 进制，最低为二进制。

请你算出 A−B 的结果最小可能是多少。

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

输入格式

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

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

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

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

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

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

输出格式

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

数据范围

对于 30% 的数据，N≤10;  Ma,Mb≤8，
对于 100%的数据，2≤N≤1000;  1≤Ma,Mb≤100000;  A≥B。

输入样例：

11
3
10 4 0
3
1 2 0

输出样例：

94

样例解释

当进制为：最低位 2 进制，第二数位 5 进制，第三数位 11 进制时，减法得到的差最小。

此时 A 在十进制下是 108，B 在十进制下是 14，差值是 94。

思路：

先看看321->65，65=3*10*2+2*2+1

要使A-B最小，只要使数字的各位进制最小即可，就是对A和B的相同数位取 maxv=max(a[i],b[i])，然后因为最小进制为2，所以每一位的最小进制为max(maxv+1,2).

存储A和B的值，只需要开一个数组存储各位数字的权重，然后将各位数字和对应权重相乘后再相加即可。

#include 
#include 
#include 
#define int long long
using namespace std;
const int M=1e5+10,N=1010,mod=1000000007;
int a[M],b[M],w[M],qz[M];
int n,ma,mb,A,B;
int max(int a,int b){
    if(a>b) return a;
    else return b;
}
signed main(){
    cin>>n>>ma;
    for(int i=ma;i>=1;i--) cin>>a[i];
    cin>>mb;
    for(int i=mb;i>=1;i--) cin>>b[i];
    int maxm=max(ma,mb);
    for(int i=maxm;i>=1;i--){
        int maxv=max(a[i],b[i]);
        w[i]=max(maxv+1,2);
    }
    qz[1]=1;
    for(int i=2;i<=maxm;i++){
        qz[i]=(w[i-1]*qz[i-1])%mod;
    }
    for(int i=ma;i>=1;i--) A=(A+a[i]*qz[i])%mod;
    for(int i=mb;i>=1;i--) B=(B+b[i]*qz[i])%mod;
    cout<<(A-B+mod)%mod<

第六题：统计子矩阵

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

输入格式

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

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

输出格式

一个整数代表答案。

数据范围

对于 30% 的数据，N,M≤20
对于 70% 的数据，N,M≤100
对于 100% 的数据，1≤N,M≤500;0≤Aij≤1000;1≤K≤2.5×10e8

输入样例：

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

输出样例：

19

样例解释

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

• 大小为 1×1 的有 10 个。
• 大小为 1×2 的有 3 个。
• 大小为 1×3 的有 2个。
• 大小为 1×4 的有 1 个。
• 大小为 2×1 的有 3 个。

思路：二维前缀和+双指针

直接暴力枚举的话，复杂度将是O(N^4)，会超时

使用双指针优化：

使用4个指针枚举子矩阵的四个方向，如果子矩阵的和大于k，则后面的指针前进，直到子矩阵的和不大于k

#include
using namespace std;
typedef long long ll;
const int N = 5e2+3;
int n, m, k;
int a[N][N];
int main(){
    ios::sync_with_stdio(false);
    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 i=1; i<=m; i++){
        for(int j=i; j<=m; j++){
            for(int s = 1, t = 1; t <= n; t ++ ){
                // (t,j)~(s,i)的二维前缀和
                while(s <= t && a[t][j] - a[s - 1][j] - a[t][i - 1] + a[s - 1][i - 1] > k) s ++ ;
                if(s <= t) ans += t - s + 1;
            }
        }
    }
    cout << ans << '\n';
    return 0;
}

第七题：积木画

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

同时，小明有一块面积大小为 2×N2×N 的画布，画布由 2×N2×N 个 1×11×1 区域构成。

小明需要用以上两种积木将画布拼满，他想知道总共有多少种不同的方式？

积木可以任意旋转，且画布的方向固定。

输入格式

输入一个整数 NN，表示画布大小。

输出格式

输出一个整数表示答案。

由于答案可能很大，所以输出其对 10000000071000000007 取模后的值。

数据范围

1≤N≤1071≤N≤107。

输入样例：

3

输出样例：

5

样例解释

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

思路：状态压缩dp

f(i,j)表示已经操作完前i-1列，且第i列的状态为j的所有方案的集合

#include 
#include 
using namespace std;
const int N = 1e7 + 10, mod = 1000000007;
int g[4][4] = {
    // g数组的第一维是当前状态，第二维是目标转化状态，用二进制转十进制表示
    {1, 1, 1, 1},
    {0, 0, 1, 1},
    {0, 1, 0, 1},
    {1, 0, 0, 0},
};
int f[N][4];
int main() {
    int n;
    cin >> n;
    f[1][0] = 1;
    for (int i = 1; i <= n; i ++ )
        for (int j = 0; j < 4; j ++ )
            for (int k = 0; k < 4; k ++ ) {
                f[i + 1][k] = (f[i + 1][k] + f[i][j] * g[j][k]) % mod;
            }
    cout << f[n + 1][0];
    return 0;
}

第八题：扫雷

小明最近迷上了一款名为《扫雷》的游戏。

其中有一个关卡的任务如下：

在一个二维平面上放置着 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≤109,0≤n,m≤103,1≤r≤10，
对于 100% 的评测用例：0≤x,y≤109,0≤n,m≤5×104,1≤r≤10。

输入样例：

2 1
2 2 4
4 4 2
0 0 5

输出样例：

2

样例解释

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

思路：哈希表 图的遍历

建图，把每个雷看成是图中的一个点，暴搜每一个点，使用st表保证每个点只被搜索到一次。

#include 

using namespace std;

typedef long long ll;
const int N = 50010, M = 999997;
int n, m;
struct Circle{
    int x, y, r;
}cir[N];
ll h[M];
int id[M];
bool st[M];

ll get_key(int x, int y){
    return 1ll * x * 1000000001 + y;    
}

int find(int x, int y){
    ll key = get_key(x, y);
    int t = (key % M + M) % M;

    while(h[t] != -1 && h[t] != key){
        if( ++ t == M) {
            t = 0;
        }
    }
    return t;
}

int sqr(int x){
    return x * x;
}

void dfs(int x, int y, int r){
    st[find(x, y)] = true;
    for (int i = x - r; i <= x + r; ++ i) {
        for (int j = y - r; j <= y + r; ++ j) {
            if (sqr(i - x) + sqr(j - y) <= sqr(r)) {
                int t = find(i, j);
                if (id[t] && !st[t])
                    dfs(i, j, cir[id[t]].r);
            }
        }
    }
}

int main(){
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i ++){
        int x, y, r;
        scanf("%d%d%d", &x, &y, &r);
        cir[i] = {x, y, r};
        int t = find(x, y);
        if(h[t] == -1) h[t] = get_key(x, y);

        if(!id[t] || cir[id[t]].r < r) id[t] = i;
    }

    while(m --){
        int x, y, r;
        scanf("%d%d%d", &x, &y, &r);

        for (int i = x - r; i <= x + r; i ++){
            for (int j = y - r; j <= y + r; ++j){
                if (sqr(j-y) + sqr(i-x) <= sqr(r)){
                    int t = find(i, j);
                    if(id[t] && !st[t]){
                        dfs(i, j, cir[id[t]].r);
                    }
                }
            }
        }
    }

    int res = 0;
    for (int i = 1; i <= n; ++i){
        if (st[find(cir[i].x, cir[i].y)]) ++res;
    }
    cout<

第九题：李白打酒加强版

话说大诗人李白，一生好饮。

幸好他从不开车。

一天，他提着酒壶，从家里出来，酒壶中有酒 2 斗。

他边走边唱：

无事街上走，提壶去打酒。

逢店加一倍，遇花喝一斗。

这一路上，他一共遇到店 N 次，遇到花 M 次。

已知最后一次遇到的是花，他正好把酒喝光了。

请你计算李白这一路遇到店和花的顺序，有多少种不同的可能？

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

输入格式

第一行包含两个整数 N 和 M。

输出格式

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

数据范围

对于 40% 的评测用例：1≤N,M≤10。
对于 100% 的评测用例：1≤N,M≤100。

输入样例：

5 10

输出样例：

14

样例解释

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

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

思路：f[i][j][k]表示经过了i个花，j个店，手里有k斗酒的合法方案。

状态计算：f[i][j][k]分为最后一步到花，和最后一步到店，f[i][j][k]=f[i-1][j][k+1]+f[i][j-1][k/2].

初始化的时候把 f[0][0][2] 初始化为1，其他 f[0][0][k] 都为0，
表示一开始只有李白手里拿2斗酒这一种情况，最后答案是f[n - 1][m][1]。

#include
using namespace std;
const int N = 110, M = 1000000007;
int n, m, f[N][N][N];
int main() {
    scanf("%d%d", &m, &n);
    for(int i = 0; i <= n; i ++ ) {
        for(int j = 0; j <= m; j ++ ) {
            for(int k = 0; k < N; k ++ ) {
                if(i == 0 && j == 0 && k == 2)
                f[i][j][k] = 1;
                if(i == 0 && j == 0)
                continue;
                if(i > 0)
                f[i][j][k] = (f[i][j][k] + f[i - 1][j][k + 1]) % M;
                if(j > 0 && k % 2 == 0)
                f[i][j][k] = (f[i][j][k] + f[i][j - 1][k / 2]) % M;
            }
        } 
    }
    printf("%d", f[n - 1][m][1]);
    return 0;
} 

第十题：砍竹子

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

他觉得一棵一棵砍太慢了，决定使用魔法来砍竹子。

魔法可以对连续的一段相同高度的竹子使用，假设这一段竹子的高度为 H，那么使用一次魔法可以把这一段竹子的高度都变为 ⌊√⌊H2⌋/2+1⌋，其中 ⌊x⌋ 表示对 x 向下取整。

小明想知道他最少使用多少次魔法可以让所有的竹子的高度都变为 1。

输入格式

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

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

输出格式

一个整数表示答案。

数据范围

对于 20%的数据，保证1≤n≤1000,1≤hi≤106。
对于 100% 的数据，保证 1≤n≤2×105,1≤hi≤1018。

输入样例：

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

共需要 55 步完成。

思路：最长公共下降子序列

对于任意一个h,只要它高度降到了与前一个高度下降过程中的公共值，那么它就不需要花费代价继续下降。如果它降得的当前高度与前一个高度没有公共值，则需要多花费一个代价，来降低自己的高度。我们只需要开两个数组暴力做一下就行。

#include 
using namespace std;
typedef long long LL;
const int N = 2e5 + 10;
LL a[N];
vector b[N];
int n;
LL solve(LL x) {
    return sqrt(x / 2 + 1);
}
int main() {
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++ ) scanf("%lld", &a[i]);
    int res = 0;
    for(int i = 1; i <= n; i ++ ) {
        while(a[i] > 1) {
            int flag = 0;
            for(LL j : b[i - 1]) {
                if(a[i] == j) {
                    flag = 1;
                    break;
                }
            }
            if(!flag) res ++;
            b[i].push_back(a[i]);
            a[i] = solve(a[i]);
        }

    }
    printf("%d", res);

    return 0;
}