蓝桥杯2022年c/c++b组省赛真题java版，备战2023年蓝桥杯大赛
试题 A: 九进制转十进制
本题总分：5 分
【问题描述】
九进制正整数 (2022)9 转换成十进制等于多少？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
1478
每一位数乘以对应的位权，没啥好讲的
public class A {
public static void main(String[] args) {
System.out.println(2+2*9+2*729);
}
}试题 B: 顺子日期
本题总分：5 分
【问题描述】
小明特别喜欢顺子。顺子指的就是连续的三个数字：123、456 等。顺子日期指的就是在日期的 yyyymmdd 表示法中，存在任意连续的三位数是一个顺子的日期。例如 20220123 就是一个顺子日期，因为它出现了一个顺子：123；而 20221023 则不是一个顺子日期，它一个顺子也没有。小明想知道在整个 2022年份中，一共有多少个顺子日期。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
14
这题题意不明确，正序是顺子倒序是不是顺子呢？包不包含0呢？只能根据样例20221023判断倒序是不算在内的，0题目没有特殊说明感觉就是包含的。
由于年份最后一位是2，无法升序，则年份不影响答案，所以只要判断月和日的组合，记得补零凑齐位数。
public class B {
public static void main(String[] args) {
int[] date={0,31,28,31,30,31,30,31,31,30,31,30,31};
int res=0;
for (int i = 1; i <= 12; i++) {
String s=(i>=10?""+i:"0"+i);
for (int j = 1; j <=date[i]; j++) {
char[] c = (s + (j>=10?j:"0"+j)).toCharArray();
int cnt=1;
for (int k = 1; k < c.length; k++) {
cnt+=c[k]==c[k-1]+1?1:1-cnt;
if (cnt>=3) {
res++;
break;
}
}
}
}
System.out.println(res);
}
}试题 C: 刷题统计
时间限制: 1.0s 内存限制: 256.0MB 本题总分：10 分
【问题描述】
小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天做 a 道题目，周六和周日每天做 b 道题目。请你帮小明计算，按照计划他将在第几天实现做题数大于等于 n 题？
【输入格式】
输入一行包含三个整数 a, b 和 n.
【输出格式】
输出一个整数代表天数。
【样例输入】
10 20 99【样例输出】
8【评测用例规模与约定】
对于 50% 的评测用例，1 ≤ a, b, n ≤ 106.
对于 100% 的评测用例，1 ≤ a, b, n ≤ 1018.
以每周的刷题数为单位对总题数整除并乘以7天+以每周的刷题数为单位对总题数取余求天数。说得有点乱，上代码。
import java.util.Scanner;
public class C {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
long a=sc.nextLong(),b=sc.nextLong(),c=sc.nextLong();
long week=a*5+b*2,res=0;
res+=c/week*7;
long t=c%week,cnt=0;
while(t>0&&cnt<5){
t-=a;
cnt++;
res++;
}
while (t>0&&cnt<7){
t-=b;
cnt++;
res++;
}
System.out.println(res);
}
}试题 D: 修剪灌木
时间限制: 1.0s 内存限制: 256.0MB 本题总分：10 分
【问题描述】
爱丽丝要完成一项修剪灌木的工作。
有 N 棵灌木整齐的从左到右排成一排。爱丽丝在每天傍晚会修剪一棵灌木，让灌木的高度变为 0 厘米。爱丽丝修剪灌木的顺序是从最左侧的灌木开始，每天向右修剪一棵灌木。当修剪了最右侧的灌木后，她会调转方向，下一天开始向左修剪灌木。直到修剪了最左的灌木后再次调转方向。然后如此循环往复。灌木每天从早上到傍晚会长高 1 厘米，而其余时间不会长高。在第一天的早晨，所有灌木的高度都是 0 厘米。爱丽丝想知道每棵灌木最高长到多高。
【输入格式】
一个正整数 N ，含义如题面所述。
【输出格式】
输出 N 行，每行一个整数，第行表示从左到右第 i 棵树最高能长到多高。
【样例输入】
3【样例输出】
4
2
4【评测用例规模与约定】
对于 30% 的数据，N ≤ 10.
对于 100% 的数据，1 < N ≤ 10000
找到当前灌木距离头和尾的最大值的两倍，即当前灌木能长到的最大高度
import java.util.Scanner;
public class D {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
for (int i = 1; i <= n; i++) {
System.out.println(Math.max(i-1,n-i)*2);
}
}
}试题 E: X 进制减法
时间限制: 1.0s 内存限制: 256.0MB 本题总分：15 分
【问题描述】
进制规定了数字在数位上逢几进一。
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 的结果。
【样例输入】
11
3
10 4 0
3
1 2 0【样例输出】
94【样例说明】
当进制为：最低位 2 进制，第二数位 5 进制，第三数位 11 进制时，减法得到的差最小。此时 A 在十进制下是 108，B 在十进制下是 14，差值是 94。
【评测用例规模与约定】
对于 30% 的数据，N ≤ 10; Ma, Mb ≤ 8.
对于 100% 的数据，2 ≤ N ≤ 1000; 1 ≤ Ma, Mb ≤ 100000; A ≥ B.
贪心，每一位取最小进制即可。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
public class E {
static StreamTokenizer st=new StreamTokenizer(
new BufferedReader(new InputStreamReader(System.in)));
static int nextInt(){
try {
st.nextToken();
} catch (IOException e) {
e.printStackTrace();
}
return (int) st.nval;
}
public static void main(String[] args) {
int k=nextInt(),n=nextInt(),m,N=100000,mod= (int) (1e9+7);
int[] a=new int[N+10],b=new int[N+10];
for (int i = N-n+1; i <=N; i++) a[i]=nextInt();
m=nextInt();
for (int i = N-m+1; i <=N; i++) b[i]=nextInt();
long x=1,res=0;
for (int i = N; i >=N-Math.max(m,n)+1 ; i--) {
res=(res+(a[i]-b[i])*x)%mod;
x=(x*Math.max(2,Math.max(a[i],b[i])+1))%mod;
}
System.out.println(res);
}
}
试题 F: 统计子矩阵
时间限制: 1.0s 内存限制: 256.0MB 本题总分：15 分
【问题描述】
给定一个 N × M 的矩阵 A，请你统计有多少个子矩阵 (最小 1 × 1，最大N × 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 × 1 的有 10 个。
大小为 1 × 2 的有 3 个。
大小为 1 × 3 的有 2 个。
大小为 1 × 4 的有 1 个。
大小为 2 × 1 的有 3 个。
【评测用例规模与约定】
对于 30% 的数据，N, M ≤ 20.
对于 70% 的数据，N, M ≤ 100.
对于 100% 的数据，1 ≤ N, M ≤ 500; 0 ≤ Ai j ≤ 1000; 1 ≤ K ≤ 250000000.
写出矩阵前缀和，暴力会超时，需要对一个维度进行优化，当左上角的点的坐标和行数确定之后，随着y轴增大，矩阵随之变大，矩阵和也跟着增大，因此y轴从大到小线性查找到第一个小于等于k的矩阵，比当前y小的矩阵同样小于k。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
public class F {
static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
static int nextInt(){
try {
st.nextToken();
} catch (IOException e) {
e.printStackTrace();
}
return (int)st.nval;
}
static int n,m,k,N=510;
static long[][] b=new long[N][N];
public static void main(String[] args) {
n=nextInt();m=nextInt();k=nextInt();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
b[i][j]=nextInt();
b[i][j]+=b[i-1][j]+b[i][j-1]-b[i-1][j-1];
}
}
long res=0;
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=m ; j++) {
int y=m;
for (int x = i; x <= n; x++) {
while (j<=y&&b[x][y]-b[x][j-1]-b[i-1][y]+b[i-1][j-1]>k) y--;
if (y<j) break;
res+=y-j+1;
}
}
}
System.out.println(res);
}
}
试题 G: 积木画
时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分
【问题描述】
小明最近迷上了积木画，有这么两种类型的积木，分别为 I 型（大小为 2个单位面积）和 L 型（大小为 3 个单位面积）：
同时，小明有一块面积大小为 2 × N 的画布，画布由 2 × N 个 1 × 1 区域构成。小明需要用以上两种木将画布拼满，他想知道总共有多少种不同的方式？积木可以任意旋转，且画布的方向固定。
【输入格式】
输入一个整数 N，表示画布大小。
【输出格式】
输出一个整数表示答案。由于答案可能很大，所以输出其对 1000000007 取模后的值
【样例输入】
3【样例输出】
5
【评测用例规模与约定】
对于所有测试用例，1 ≤ N ≤ 10000000.
典型的动态规划问题。维护一个二维数组f[i][j]表示方式数，i表示当前位置状态，0表示上面有方块下面没有，1表示下面有方块上面没有，2表示上下都有方块。
那么我们可以很清楚的写出状态转移方程,这里不作图不好讲，懒得作图了，可以根据上面的状态去理解转移方程。
import java.util.Scanner;
public class G {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt(),mod= (int) (1e9+7),N=10000010;
int[][] f=new int[3][N];
f[2][1]=f[0][2]=f[1][2]=1;
f[2][2]=2;
for (int i = 3; i <=n ; i++) {
f[0][i]=(f[1][i-1]+f[2][i-2])%mod;
f[1][i]=(f[0][i-1]+f[2][i-2])%mod;
f[2][i]=(((f[2][i-2]+f[2][i-1])%mod+f[0][i-1])%mod+f[1][i-1])%mod;
}
System.out.println(f[2][n]);
}
}试题 H: 扫雷
时间限制: 1.0s 内存限制: 256.0MB 本题总分：20 分
【问题描述】
小明最近迷上了一款名为《扫雷》的游戏。其中有一个关卡的任务如下，在一个二维平面上放置着 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，表示一个排雷火箭的信息。
【输出格式】
输出一个整数表示答案。
【样例输入】
2 1
2 2 4
4 4 2
0 0 5【样例输出】
2
【评测用例规模与约定】
对于 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.
模拟题，典型的dfs题目，这里我用了排序加二分优化，我不知道没优化会不会过。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;
public class H {
static StreamTokenizer st=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
static int nextInt(){
try {
st.nextToken();
} catch (IOException e) {
e.printStackTrace();
}
return (int) st.nval;
}
static int n,m,N=50010,cnt=0,res=0;
static Node[] a=new Node[N],b=new Node[N];
static int[] vis=new int[N];
public static void main(String[] args) {
n=nextInt();m=nextInt();
for (int i = 1; i <= n; i++) {
a[i]=new Node(nextInt(),nextInt(),nextInt());
}
Arrays.sort(a,1,n+1,(o1,o2)->o1.x-o2.x);
for (int i = 1; i <= m; i++) {
b[i]=new Node(nextInt(),nextInt(),nextInt());
dfs(b[i]);
res+=cnt;
cnt=0;
}
System.out.println(res);
}
static void dfs(Node u){
int idx = getIdx(u.x-u.r);
if (idx==-1) return;
while (idx<=n&&a[idx].x<=u.x+u.r){
if (vis[idx]==1) {
idx++;
continue;
}
double dis = dis(u.x, u.y, a[idx].x,a[idx].y);
if (dis<=u.r){
vis[idx]=1;
dfs(a[idx]);
cnt++;
}
idx++;
}
}
static int getIdx(int d){
int l=1,r=n;
while (l<r){
int mid=l+r>>1;
if (a[mid].x>=d) r=mid;
else l=mid+1;
}
if (l==n&&a[l].x<d) return -1;
return l;
}
static double dis(int x1,int y1,int x2,int y2){
return Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
}
static class Node{
int x,y,r;
public Node(int x, int y, int r) {
this.x = x;
this.y = y;
this.r = r;
}
}
}
试题 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 ≤ N, M ≤ 10。
对于 100% 的评测用例：1 ≤ N, M ≤ 100。
又是动态规划，维护一个四维数组f表示可能性，第一维0表示遇到花，1表示遇到店，第二维表示经过花和店的总次数，第三维表示遇到店的次数，第四维表示当前剩余的酒数量。后面自行看代码理解吧
import java.util.Scanner;
public class I {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt(),m=sc.nextInt(),N=110,mod= (int) (1e9+7);
int[][][][] f=new int[2][N*2][N][N];
f[0][1][0][1]=1;
f[1][1][1][4]=1;
for (int i = 2; i <=n+m ; i++) {
for (int j = 1; j <=Math.min(n,i) ; j++) {
for (int k = 0; k <= m ; k++) {
if ((k&1)==0) f[1][i][j][k]=(f[0][i-1][j-1][k/2]+f[1][i-1][j-1][k/2])%mod;
f[0][i][j][k]=(f[0][i-1][j][k+1]+f[1][i-1][j][k+1])%mod;
}
}
}
System.out.println(f[0][n+m][n][0]);
}
}
试题 J: 砍竹子
时间限制: 1.0s 内存限制: 256.0MB 本题总分：25 分
【样例输入】
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 ≤ 1000, hi ≤ 106。
对于 100% 的数据，保证 n ≤ 2 × 105, hi ≤ 1018。
持续更新......
心情不太好，写得很随意，见谅！有问题可以提出来
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
