第十三届蓝桥杯省赛 JAVA B组（真题解析+个人体会）（已更新完G题）
Posted 奶味蓝呀
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第十三届蓝桥杯省赛 JAVA B组（真题解析+个人体会）（已更新完G题）相关的知识，希望对你有一定的参考价值。
试题 A: 星期计算【填空题】
题目：
答案：7
解析：
此题直接对7求余即可。
public class Main
public static void main(String[] args)
System.out.println(Math.pow(20, 22) % 7 + 6);
贴一个BigInteger的代码
import java.math.BigInteger;
public class Main
public static void main(String[] args)
BigInteger bg = new BigInteger(20+"");
BigInteger res = bg.pow(22).remainder(BigInteger.valueOf(7)).add(BigInteger.valueOf(6));
System.out.println(res);
试题 B:【填空题】
题目：
答案：3138
这题我知道很多人把题目都给看错了，我认识好几个都是只看到了回文，没看到还有单调的条件。（大佬们都忙着做后面的题）
解析：
读题可以知道，回文数左右对称，所以只需判断是否回文，然后再判断左边的数单调不减，则右边的数一定单调不增。判断回文数可以使用双指针判断。
public class Main
public static void main(String[] args)
long start = System.currentTimeMillis();
int count = 0;
for (int i = 2022; i <= 2022222022; i++)
if (isPalindrome(i) && check(i))
count++;
long end = System.currentTimeMillis();
System.out.println(count);
System.out.println("共用时" + (end - start) / 1000 % 60 + "秒");//测了一下时间用时40s
private static boolean check(int num)
String s = num + "";
for (int i = 0; i < s.length() / 2; i++)
if (s.charAt(i) > s.charAt(i + 1)) return false;
return true;
private static boolean isPalindrome(int num)
String s = num + "";
int n = s.length() - 1;
for (int l = 0, r = n; l < r; l++, r --)
if (s.charAt(l) != s.charAt(r)) return false;
return true;
试题 C:字符统计【编程题】
题目：
解析：
签到题,分别统计输出即可。
import java.util.Scanner;
public class Main
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int[] arr = new int[26];
for (int i = 0; i < s.length(); i++)
arr[s.charAt(i) - 'A']++;
int max = Integer.MIN_VALUE;
for (int i = 0; i < 26; i++)
max = Math.max(max, arr[i]);
for (int i = 0; i < 26; i++)
if(arr[i] == max) System.out.print((char) (i+'A'));
试题 D:最少刷题数【编程题】
题目：
解析：
这个题我觉得虽然是个十分题，但是还是挺难的（也可能是我太菜了）。主要是要考虑的因素比较多，核心的想法应该是要计算出左边、右边与中间相等的数的个数，分情况判断每个数加上最小刷题数与中间数相等后需不需要+1。
这题当时给我做烦了，浪费了很多时间，我只考虑了和中间的相比，比它大就输出0，比它小就输出中间的数减去num[i]+1，并没有判断左右数与中间数相等的情况，没有全部AC。这里贴一下别人的代码
import java.util.Arrays;
import java.util.Scanner;
public class Main
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] nums = new int[n];
int[] temp = new int[n];
for (int i = 0; i < n; i++)
nums[i] = sc.nextInt();
temp[i] = nums[i];
// 排序数组
Arrays.sort(temp);
// 中间的下标
int midIndex = n / 2;
// 中间的值
int midValue = temp[midIndex];
int midOption = 0;
int option = 0;
// 左边和中值相同值的数量
int sameLeft = 0;
// 右边和中值相同值的数量
int sameRight = 0;
for (int i = midIndex - 1, j = midIndex; i >= 0; i--, j++)
if (temp[i] == midValue)
sameLeft++;
if (temp[j] == midValue)
sameRight++;
if (temp[i] != temp[j])
break;
if (sameLeft >= sameRight)
option = 1;
if (sameLeft > sameRight)
midOption = 1;
for (int i = 0, len = nums.length; i < len; i++)
int count = 0;
if (nums[i] == midValue)
count = midOption;
else
count = midValue - nums[i] + option;
if (count < 0)
count = 0;
if (i != n - 1)
System.out.print(count + " ");
else
System.out.println(count);
我觉得这个代码的方法还是比较巧妙的hh
-------------------------------------------------------------分界线-----------------------------------------------------------
2023年2月7日更新
核心思想：排序找中位数，然后统计左右两边比mid大和比mid小的数，分类讨论。
(感觉像个模拟题)挺烦的十分题
import java.util.Arrays;
import java.util.Scanner;
public class Main
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n], tmp = new int[n];
for (int i = 0; i < n; i++)
a[i] = sc.nextInt();
tmp[i] = a[i];
Arrays.sort(tmp);
int mid = tmp[n / 2];
int bg_cnt = 0, sml_cnt = 0; // 记录比mid大的和比mid小的数
for (int i = 0; i < n; i++)
if (a[i] < mid) sml_cnt ++;
else if (a[i] > mid) bg_cnt ++;
if (bg_cnt < sml_cnt)
for (int i = 0; i < n; i++)
if (a[i] < mid) System.out.print(mid - a[i] + " ");
else System.out.print(0 + " ");
else if (bg_cnt == sml_cnt)
for (int i = 0; i < n; i++)
if (a[i] < mid) System.out.print(mid - a[i] + 1 + " ");
else System.out.print(0 + " ");
else
for (int i = 0; i < n; i++)
if (a[i] <= mid) System.out.print(mid - a[i] + 1 + " ");
else System.out.print(0 + " ");
试题 E: 求阶乘
题目：
解析
这题我又给想简单了，此题的数据范围非常大，所以可能只能过极个别样例。也不能直接从1到N枚举判断，突破口是数字中谁和谁相乘得到10，很容易想到2*5，2的个数肯定比5多，所以N的阶乘最后有多少0 就看N能分成多少5 。可以从1~N每个数都除以5，然后统计个5的个数，因为25/5也会得到5，所以需要用循环计算。
暴力法
import java.util.Scanner;
public class Main
//后面以0 结尾的一定是5！....(5的倍数的阶乘) 所以只需要判断5的倍数的阶乘
//(判断的数)/5 就是含有5的个数 也是阶乘后0的个数
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
long k = sc.nextLong();
long count;
long a = 5;//直接从5的阶乘(120)开始判断
while (true)
long tempA = a;
count = 0;
while (tempA > 0)
tempA /= 5;
count += tempA;
if (count < k)
a += 5;
else if (count == k)
System.out.println(a);
break;
else
System.out.println(-1);
break;
-------------------------------------------------------------分界线-----------------------------------------------------------
2023年2月8日更新
二分
N 越大，末尾的 0 越多，具有单调性，可以使用二分找到答案。
import java.util.Scanner;
public class Main
// 找N里面有多少个5(25里有两个5) 二分出一个>=k(找大于等于k的第一个位置)的最小的N，不存在则输出-1
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
long l = 1, r = Long.MAX_VALUE-5;
long k = sc.nextLong();
while (l < r)
long mid = l + r >> 1;
if (cal(mid) >= k) r = mid;
else l = mid + 1;
if (cal(r) == k) System.out.println(r);
else System.out.println(-1);
private static long cal(long num)
long cnt = 0;
while (num > 0)
cnt += num / 5;
num /= 5;
return cnt;
试题 F: 最大子矩阵
题目：
解析：单调队列+二分
这题感觉比G题还难做，考试只能打打暴力了....
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;
// 枚举行x1,x2,二分最大的列数len,维护滑动窗口为大小为len的最大值和最小值
// 单调队列+二分
public class Main
// 矩阵中最大值-最小值<=limit && 元素个数最多
static int n, m, limit, ans;
static int[][][] max, min;
//max[k][i][j]代表的含义是在第k列中，第i个元素到第j个的元素最大值是多少，min数组同理。
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
n = sc.nextInt(); m = sc.nextInt();
max = new int[m + 1][n + 1][n + 1]; min = new int[m + 1][n + 1][n + 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
max[j][i][i] = min[j][i][i] = sc.nextInt();
limit = sc.nextInt();
for (int k = 1; k <= m; k++)
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
max[k][i][j] = Math.max(max[k][j][j], max[k][i][j - 1]);
min[k][i][j] = Math.min(min[k][j][j], min[k][i][j - 1]);
for (int x1 = 1; x1 <= n; x1++)
for (int x2 = x1; x2 <= n; x2++)
int l = 1, r = m;
while (l < r)
int mid = l + r + 1 >> 1;
if (check(x1, x2, mid)) l = mid;
else r = mid - 1;
if (check(x1, x2, r)) ans = Math.max(ans, (x2 - x1 + 1) * r);
System.out.println(ans);
private static boolean check(int x1, int x2, int k)
Deque<Integer> q_min = new ArrayDeque<>();
Deque<Integer> q_max = new ArrayDeque<>();
// 枚举所有列
for (int i = 1; i <= m; i++)
if (!q_min.isEmpty() && i - k >= q_min.peekFirst()) q_min.pollFirst();
while (!q_min.isEmpty() && min[i][x1][x2] <= min[q_min.peekLast()][x1][x2]) q_min.pollLast();
q_min.addLast(i);
if (!q_max.isEmpty() && i - k >= q_max.peekFirst()) q_max.pollFirst();
while (!q_max.isEmpty() && max[i][x1][x2] >= max[q_max.peekLast()][x1][x2]) q_max.pollLast();
q_max.addLast(i);
//窗口大小为k
if (i >= k && max[q_max.peekFirst()][x1][x2] - min[q_min.peekFirst()][x1][x2] <= limit) return true;
return false;
试题 G:数组切分
题目：
解析：
算法1 回溯算法
枚举所有分割点
回溯算法可以枚举所有情况，当每个切分的子数组都满足题目要求时，答案++，但时间复杂度较高，会tle
小技巧
问 : 如何判断区间[i,j]是否可以组成一段连续的自然数？
答 ：只需 区间最大值 - 区间最小值 == j - i (区间长度)即可
import java.util.LinkedList;
import java.util.Scanner;
public class Main
static LinkedList<Integer> path = new LinkedList<>();
static int res = 0, mod = 1000000007;
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = sc.nextInt();
dfs(a, 0);
System.out.println(res % mod);
private static void dfs(int[] a, int startindex)
int n = a.length;
if (startindex == n)
res ++;
return;
for (int i = startindex; i < n; i++)
if (check(a, startindex, i))
path.add(i);
dfs(a, i + 1);
path.removeLast();
private static boolean check(int[] a, int l, int r)
int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
for (int i = l; i <= r; i++)
if (a[i] > max) max = a[i];
if (a[i] < min) min = a[i];
return max - min == r - l;
算法2 DP(正解)
import java.util.Scanner;
public class Main
static int mod = 1000000007;
public static void main(String[] args)
// f[i]: 以a[i]结尾的切分合法数组的方法数量
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n + 1];
for (int i = 1; i <= n; i++) a[i] = sc.nextInt();
int[] f = new int[n + 1];
f[0] = 1;
for (int i = 1; i <= n; i++)
int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
for (int j = i; j > 0; j--)
max = Math.max(max, a[j]);
min = Math.min(min, a[j]);
//如果a[j, i]是一段连续的自然数，那么就有以a[i]结尾的合法切分合法数量+=以a[j - 1]结尾的合法切分数量
//即f[i] += f[j - 1]
if (max - min == i - j)
f[i] = (f[i] + f[j - 1]) % mod;
System.out.println(f[n]);
试题 H: 回忆迷宫
题目：
解析：
试题 I: 红绿灯
题目：
解析：
试题 J: 拉箱子
题目：
解析：
第十三届蓝桥杯省赛C++B组 真题题解（详细讲解+代码分析）看这篇就够了~~~
第十三届蓝桥杯省赛C++B组 真题题解
A.九进制转十进制
题目描述
九进制正整数(2022)9转换成十进制等于多少？
思路
2 * 9^3 + 0 * 9^2 + 2 * 9^1 + 2 * 9^0=1478
答案：1478
B.顺子日期
题目描述
小明特别喜欢顺子。顺子指的就是连续的三个数字：123、456等。顺子日期指的就是在日期的yyyymmdd表示法中，存在任意连续的三位数是一个顺子的日期。例如20220123就是一个顺子日期，因为它出现了一个顺子：123；而20221023则不是一个顺子日期，它一个顺子也没有。小明想知道在整个2022年份中，一共有多少个顺子日期。
思路
由于只需要判断2022年这一个年份，所以，只需要手写几个日期即可
答案
题目未说明012是否属于顺子，所以，如果012属于顺子，则答案为14，否则，答案为4。（321倒序应该不属于顺子）
C.刷题统计
题目描述
小明决定从下周一开始努力刷题准备蓝桥杯竞赛。
他计划周一至周五每天做 a 道题目，周六和周日每天做 b 道题目。
请你帮小明计算，按照计划他将在第几天实现做题数大于等于 n 题？
输入格式
输入一行包含三个整数 a,b 和 n。
输出格式
输出一个整数代表天数。
数据范围
对于 50% 的评测用例，1≤a,b,n≤106，
对于 100% 的评测用例，1≤a,b,n≤1018。
输入样例：
10 20 99
输出样例：
8
思路
简单模拟
一周之内可以写的题目数 sum=5a+2b
所有题目一共需要多少周 ans=n / sum ，这些周的天数为ans=ans*7
还剩余不够达到一周的题目数 res=n%sum
AC代码
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
ll a,b,n;
cin>>a>>b>>n;
ll sum=5*a+2*b;
ll ans=n/sum*7;
ll res=n%sum;
ll date[7]=a,a,a,a,a,b,b;
for(int i=0;res>0;i++)
res-=date[i];
ans++;
cout<<ans<<endl;
return 0;
D.修剪灌木
题目描述
爱丽丝要完成一项修剪灌木的工作。
有 N 棵灌木整齐的从左到右排成一排。
爱丽丝在每天傍晚会修剪一棵灌木，让灌木的高度变为 0 厘米。
爱丽丝修剪灌木的顺序是从最左侧的灌木开始，每天向右修剪一棵灌木。
当修剪了最右侧的灌木后，她会调转方向，下一天开始向左修剪灌木。
直到修剪了最左的灌木后再次调转方向。
然后如此循环往复。
灌木每天从早上到傍晚会长高 1 厘米，而其余时间不会长高。
在第一天的早晨，所有灌木的高度都是 0 厘米。爱丽丝想知道每棵灌木最高长到多高。
输入格式
一个正整数 N，含义如题面所述。
输出格式
输出 N 行，每行一个整数，第行表示从左到右第 i 棵树最高能长到多高。
数据范围
对于 30% 的数据，N≤10，
对于 100% 的数据，1<N≤10000。
输入样例：
3
输出样例：
4
2
4
思路
先模拟整个过程，找出规律
每个灌木最高能长到的高度就是从它走到的最远的边界再回来的距离
换成公式就是2*(边界-自身位置)
AC代码
#include<bits/stdc++.h>
using namespace std;
int main()
int n;
cin>>n;
for(int i=1;i<=n;i++)
//因为边界有左右两边界，需找出离左右边界的最大值的2倍
cout<<max(i-1,n-i)*2<<endl;
return 0;
E.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。
思路
推出进制计算方式:每一位数字,乘以该数字数位后所有进制数,求和即为结果
欲使A-B最小，只需使得各位数字取得合法范围内的最小进制即可，具体做法就是对A和B中相同数位的数字取xmax = max(a[i], b[i])，该位的合法最小进制即为max(xmax + 1, 2)
因为最小进制不能小于2；而对于X进制的数来说，合法的最大数字是X-1，例如8进制中最大数字是7，二进制中最大数字是1。
而求A和B的值，只需要再开一个数组存储各位数字的实际权重，再将各位数字和对应的权重相乘后相加即可。
需要注意的是这个题数据比较大，需要多次取模，特别是最后计算最终结果的时候，应(A - B + mod) % mod，否则可能A本来比B大，但是取模后比B小，这样A-B可能会出现负值。
AC代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10,mod=1000000007;
ll a[N],b[N],w[N],mul[N];
ll A,B;
//a存储A各位数字,b存储B各位数字,w存储各位的进制,mul存储各位数字的实际权重
int main()
int n,ma,mb;
cin>>n; // 最大进制
cin>>ma;
for(int i=ma;i>=1;i--) cin>>a[i];
cin>>mb;
for(int i=mb;i>=1;i--) cin>>b[i];
// 确定各位进制 w[i]
int maxx=max(ma,mb); // A B 中最大的位数
for(int i=maxx;i>=1;i--)
int tmax=max(a[i],b[i]);
w[i]=max(2,tmax + 1);
// 计算权重
mul[1]=1;
for(int i=2;i<=maxx;i++)
mul[i]=w[i-1]*mul[i-1]%mod;
// 计算A
for(int i=ma;i>=1;i--)
A=(A+a[i]*mul[i])%mod;
// 计算B
for(int i=mb;i>=1;i--)
B=(B+b[i]*mul[i])%mod;
// A - B
cout<<(A-B+mod)%mod<<endl;
return 0;
F.统计子矩阵
题目描述
给定一个 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≤250000000。
输入样例：
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 个。
思路
前缀和+双指针
枚举子矩阵的上边界i和下边界j
用指针l枚举子矩阵的左边界,指针r枚举子矩阵的右边界
如果得到的子矩阵的权值和大于k,则指针l前进
所以该子矩阵的所有宽度为r-l+ 1 的子矩阵一定满足要求
AC代码
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=550;
int a[N][N];
int main()
int n,m,k;
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]; //每一列的前缀和
ll ans=0;
// 定位上下边界
for(int i=1;i<=n;i++)
for(int j=i;j<=n;j++)
for(int l=1,r=1,sum=0;r<=m;r++) //左右指针扫描
sum+=a[j][r]-a[i-1][r];
while(sum>k)
sum-=a[j][l]-a[i-1][l];
l++;
ans+=r-l+1;
cout<<ans<<endl;
return 0;
G.积木画
题目描述
小明最近迷上了积木画，有这么两种类型的积木，分别为 I 型（大小为 2 个单位面积）和 L 型（大小为 3 个单位面积）：
同时，小明有一块面积大小为 2×N 的画布，画布由 2×N 个 1×1 区域构成。
小明需要用以上两种积木将画布拼满，他想知道总共有多少种不同的方式？
积木可以任意旋转，且画布的方向固定。
输入格式
输入一个整数 N，表示画布大小。
输出格式
输出一个整数表示答案。
由于答案可能很大，所以输出其对 1000000007 取模后的值。
数据范围
1≤N≤107。
输入样例：
3
输出样例：
5
样例解释
五种情况如下图所示，颜色只是为了标识不同的积木：
思路
递推 f(i)=2*f(i-1)+f(i-3)
AC代码
#include<bits/stdc++.h>
using namespace std;
const int N=1e7+10,mod=1000000007;
int f[N];
int main()
int n;
cin>>n;
f[1]=1,f[2]=2,f[3]=5;
for(int i=4;i<=n;i++)
f[i]=(2*f[i-1]%mod+f[i-3]%mod)%mod;
cout<<f[n]<<endl;
return 0;
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≤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 也被排除。
思路
AC代码
I.李白打酒加强版
题目描述
话说大诗人李白，一生好饮。
幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒 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
思路
dp
dp[i][j][k] 表示为前i次，有j次遇到店，剩下酒为k斗。
因为n,m最大值为100，因此当k>100之后，情况必然不合法。
AC代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=220,mod=1000000007;
ll n,m,ans,len;
ll dp[N][N][N]; //前i次 有j次遇到店 剩下酒为k斗
int main()
cin>>n>>m; //N店 M花
len=n+m;
dp[0][0][2]=1; //初始有2斗酒
for(int i=1;i<=len;i++)
for(int j=0;j<=n;j++)
for(int k=0;k<=100;k++)
dp[i][j][k]+=dp[i-1][j][k+1]; //遇到花
if(j&&k%2==0) dp[i][j][k]+=dp[i-1][j-1][k/2]; //遇到店
dp[i][j][k]%=mod;
dp[len][n][0]=dp[len-1][n][1]; //最后遇到的一个一定是花
cout<<dp[len][n][0];
return 0;
J.砍竹子
题目描述
这天，小明在砍竹子，他面前有 n 棵竹子排成一排，一开始第 i 棵竹子的高度为 hi。
他觉得一棵一棵砍太慢了，决定使用魔法来砍竹子。
魔法可以对连续的一段相同高度的竹子使用，假设这一段竹子的高度为 H，那么使用一次魔法可以把这一段竹子的高度都变为 ⌊⌊H2⌋+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
共需要 5 步完成。
思路
是一个最长公共下降子序列的问题，对于任意一个h,只要它高度降到了与前一个高度下降过程中的公共值，那么它就不需要花费代价继续下降。
如果它降得的当前高度与前一个高度没有公共值，则需要多花费一个代价，来降低自己的高度
AC代码
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
ll a[N];
vector<ll>b[N];
ll fun(ll x)
return sqrt(x/2+1);
int main()
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
int ans= 0;
for(int i=1;i<=n;i++)
while(a[i]>1)
int flag = 0;
for(auto j : b[i-1])
if(a[i]==j)
flag=1;
break;
if(!flag) ans++;
b[i].push_back(a[i]);
a[i]=fun(a[i]);
cout<<ans<<endl;
return 0;
以上是关于第十三届蓝桥杯省赛 JAVA B组（真题解析+个人体会）（已更新完G题）的主要内容，如果未能解决你的问题，请参考以下文章
第十三届蓝桥杯省赛C++B组 真题题解（详细讲解+代码分析）看这篇就够了~~~