2023年十四届蓝桥杯省赛大学B组真题（Java完整版）
2023年十四届蓝桥杯省赛大学B组真题
试题A：阶乘求和
本题总分：5 分
【问题描述】
令 S = 1! + 2! + 3! + … + 202320232023!，求 S 的末尾 9 位数字。 提示：答案首位不为 0。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：420940313
【解题思路】
对于数据量大的计算题，可以先尝试把每一步的数据结果展示出来，分析规律，而这题恰巧在某一个位置后，末尾9位数字全为0，在此之前的结果就是答案，过程中记得对每个值都进行取余，否则可能会导致数值出错，得不到正确答案。
【代码】
package zhenti_2023_jiechengqiuhe;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
long sum = 0;// 数据量较大，用long
long num = 1;
for (int i = 1; true; i++) {
// 当阶乘后九位为0时，相加无意义
if (num % 1e9 == 0)
break;
num *= i;
// num结果除余对最终结果无影响，不除余会造成数据错误
num %= 1e9;
sum += num;
sum %= 1e9;
}
System.out.println(sum);
scan.close();
}
}
试题 B: 幸运数字
本题总分：5 分
【问题描述】
哈沙德数是指在某个固定的进位制当中，可以被各位数字之和整除的正整 数。例如 126 是十进制下的一个哈沙德数，因为 (126)10 mod (1+2+6) = 0；126也是八进制下的哈沙德数，因为 (126)10 = (176)8，(126)10 mod (1 + 7 + 6) = 0； 同时 126 也是 16 进制下的哈沙德数，因为 (126)10 = (7e)16，(126)10 mod (7 + e) = 0。小蓝认为，如果一个整数在二进制、八进制、十进制、十六进制下均为 哈沙德数，那么这个数字就是幸运数字，第 1 至第 10 个幸运数字的十进制表示 为：1 , 2 , 4 , 6 , 8 , 40 , 48 , 72 , 120 , 126 . . . 。现在他想知道第 2023 个幸运数 字是多少？你只需要告诉小蓝这个整数的十进制表示即可。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：215040
【解题思路】
给出一个判断是否为哈沙德数的判断式，从1开始一直循环遍历下去，并为符合条件的数标记个数，直到2023个被标记数时，获取当前值，即为答案。
【代码】
package zhenti_2023_xingyunshuzi;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
Main m1 = new Main();
int count = 0;
for (int i = 1; true; i++) {
// 判断是否为幸运数字,是则标记count
if (m1.sfhasha(i, 2) && m1.sfhasha(i, 8) && m1.sfhasha(i, 10) && m1.sfhasha(i, 16))
count++;
else {
continue;
}
// 当count为2023时，输出结果
if (count == 2023) {
System.out.println(i);
break;
}
}
scan.close();
}
/**
*
* @param i 判断是否为哈沙德数的数
* @param mod 判断的进制
* @return 判断i在mod进制下是否为哈沙德数
*/
public boolean sfhasha(int i, int mod) {
int num = i, sum = 0;
boolean sf;
while (i != 0) {
sum += i % mod;// sum为i在mod进制时的值各个位上的数之和
i /= mod;
}
sf = (num % sum) == 0;
return sf;
}
}
试题 C: 数组分割
时间限制: 2.0s 内存限制: 512.0MB 本题总分：10 分
【问题描述】
小蓝有一个长度为 N 的数组 A = [A0, A1, . . . , AN−1]。现在小蓝想要从 A 对应的数组下标所构成的集合 I = 0, 1, 2, . . . , N − 1 中找出一个子集 R1，那么 R1 在 I 中的补集为 R2。记 S 1 = ∑r∈R1 Ar，S 2 = ∑r∈R2 Ar，我们要求 S 1 和 S 2 均为 偶数，请问在这种情况下共有多少种不同的 R1。当 R1 或 R2 为空集时我们将S 1 或 S 2 视为 0。
【输入格式】
第一行一个整数 T，表示有 T 组数据。 接下来输入 T 组数据，每组数据包含两行：第一行一个整数 N，表示数组A 的长度；第二行输入 N 个整数从左至右依次为 A0, A1, . . . , AN−1，相邻元素之 间用空格分隔。
【输出格式】
对于每组数据，输出一行，包含一个整数表示答案，答案可能会很大，你 需要将答案对 1000000007 进行取模后输出。
【样例输入】
2 2 6 6 2 1 6
【样例输出】
4 0
【样例说明】
对于第一组数据，答案为 4。（注意：大括号内的数字表示元素在数组中的 下标。）
R1 = {0}, R2 = {1}；此时 S 1 = A0 = 6 为偶数, S 2 = A1 = 6 为偶数。
R1 = {1}, R2 = {0}；此时 S 1 = A1 = 6 为偶数, S 2 = A0 = 6 为偶数。
R1 = {0, 1}, R2 = {}；此时 S 1 = A0 + A1 = 12 为偶数, S 2 = 0 为偶数。
R1 = {}, R2 = {0, 1}；此时 S 1 = 0 为偶数, S 2 = A0 + A1 = 12 为偶数。 对于第二组数据，无论怎么选择，都不满足条件，所以答案为 0。
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ N ≤ 10。
对于 40% 的评测用例，1 ≤ N ≤ 1 0 2 10^2 102。
对于 100% 的评测用例，1 ≤ T ≤ 10, 1 ≤ N ≤ 1 0 3 10^3 103 , 0 ≤ A i A_i Ai ≤ 1 0 9 10^9 109。
【解题思路】
通过分析，R1需要取一部分的数值，R2则取余下的部分，要想两边和都为偶数需要满足无奇数或奇数个数为偶数个，即题中奇数总个数要为偶数个，否则返回结果0，由于偶数组和奇数组相互独立，根据乘法法则，最终结果为偶数组合数乘以奇数组合数，偶数组合数=pow(2,偶数个数)，奇数组合数=pow(2,奇数个数-1)。
【代码】
package zhenti_2023_shuzufenge;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
int T;// 接收有几组数据
T = scan.nextInt();
int N;// 接收数组A的长度
int[][] A = new int[T][];// 用于存放数组内容
int[] count = new int[T];// 用于存放各组符合条件的个数，即结果答案
// 获取用户输入内容，为数组赋值，并计算结果
for (int i = 0; i
试题 D: 矩形总面积
时间限制: 2.0s 内存限制: 512.0MB 本题总分：10 分
【问题描述】
平面上有个两个矩形 R1 和 R2，它们各边都与坐标轴平行。设 (x1, y1) 和(x2, y2) 依次是 R1 的左下角和右上角坐标，(x3, y3) 和 (x4, y4) 依次是 R2 的左下 角和右上角坐标，请你计算 R1 和 R2 的总面积是多少？
注意：如果 R1 和 R2 有重叠区域，重叠区域的面积只计算一次。
【输入格式】
输入只有一行，包含 8 个整数，依次是：x1，y1，x2，y2，x3，y3，x4 和 y4。
【输出格式】
一个整数，代表答案。
【样例输入】
2 1 7 4 5 3 8 6
【样例输出】
22
【样例说明】
样例中的两个矩形如图所示：
【评测用例规模与约定】
对于 20% 的数据，R1 和 R2 没有重叠区域。
对于 20% 的数据，其中一个矩形完全在另一个矩形内部。
对于 50% 的数据，所有坐标的取值范围是 [0,
1
0
3
10^3
103]。
对于 100% 的数据，所有坐标的取值范围是 [0,
1
0
5
10^5
105]。
【解题思路】
求两个矩形合并后的面积，很容易想到先对两个矩形的面积进行求和，再减去重叠部分的面积，如果没重叠，重叠部分面积则为0，如何判断是否重叠，当最小的右上角点坐标的x，y值减去最大左下角点坐标的x，y结果>0即重叠，反之未重叠。
【代码】
package zhenti_2023_juxingzongmianji;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
int x1 = scan.nextInt(), y1 = scan.nextInt();
int x2 = scan.nextInt(), y2 = scan.nextInt();
int x3 = scan.nextInt(), y3 = scan.nextInt();
int x4 = scan.nextInt(), y4 = scan.nextInt();
// 计算面积并且减去重叠部分的面积
long area = (long) (x2 - x1) * (y2 - y1) + (long) (x4 - x3) * (y4 - y3);
int overlapWidth = Math.max(0, Math.min(x2, x4) - Math.max(x1, x3)); // 重叠部分宽度
int overlapHeight = Math.max(0, Math.min(y2, y4) - Math.max(y1, y3)); // 重叠部分高度
if (overlapWidth > 0 && overlapHeight > 0) { // 存在重叠部分
area -= (long) overlapWidth * overlapHeight;
}
System.out.println(area);
}
}
试题 E: 蜗牛
时间限制: 2.0s 内存限制: 512.0MB 本题总分：15 分
【问题描述】
这天，一只蜗牛来到了二维坐标系的原点。 在 x 轴上长有 n 根竹竿。它们平行于 y 轴，底部纵坐标为 0，横坐标分别 为 x1, x2, …, xn。竹竿的高度均为无限高，宽度可忽略。蜗牛想要从原点走到第n 个竹竿的底部也就是坐标 (xn, 0)。它只能在 x 轴上或者竹竿上爬行，在 x 轴 上爬行速度为 1 单位每秒；由于受到引力影响，蜗牛在竹竿上向上和向下爬行 的速度分别为 0.7 单位每秒和 1.3 单位每秒。 为了快速到达目的地，它施展了魔法，在第 i 和 i + 1 根竹竿之间建立了传 送门（0
【输入格式】
输入共 1 + n 行，第一行为一个正整数 n； 第二行为 n 个正整数 x1, x2, . . . , xn； 后面 n − 1 行，每行两个正整数 ai , bi+1。
【输出格式】
输出共一行，一个浮点数表示答案（四舍五入保留两位小数）。
【样例输入】
3
1 10 11
1 1
2 1
【样例输出】
4.20
【样例说明】
蜗牛路线：
(0, 0) → (1, 0) → (1, 1) → (10, 1) → (10, 0) → (11, 0)，花费时间为 1 + 1 /0.7 + 0 + 1 /1.3 + 1 ≈ 4.20
【评测用例规模与约定】
对于 20% 的数据，保证 n ≤ 15；
对于 100% 的数据，保证 n ≤
1
0
5
10^5
105 ，ai , bi ≤
1
0
4
10^4
104，xi ≤
1
0
9
10^9
109。
【解题思路】
这题主要是运用dp算法的思维来解，分析得到两种情况，一种是走到竹竿底部，一种是走到竹竿传送门起点：
dp[0][i]表示从起点走到第i根竹竿底部的时间，
dp[1][i]表示从起点走到第i根竹竿传送门起点的时间。
到达竹竿底部的关系式为
dp[0][i] = Math.min(dp[0][i - 1] + s[i], dp[1][i - 1] + y_end[i] / 1.3);
到达传送门起点要分两种情况讨论，一种是传送门终点在起点上方，另一种则是在下方，关系式为
if (y_end[i] > y_start[i]) {
dp[1][i] = Math.min(dp[0][i] + y_start[i] / 0.7, dp[1][i - 1] + (y_end[i] - y_start[i]) / 1.3);
} else {
dp[1][i] = Math.min(dp[0][i] + y_start[i] / 0.7, dp[1][i - 1] + (y_start[i] - y_end[i]) / 0.7);
}
（s[]存放竹竿间的距离，s[3]为第2根竹竿到第3根竹竿的距离，y_start[i]、y_end[i]分别为第i根竹竿传送门起点、终点在y轴的坐标）
【代码】
package zhenti_2023_woniu;
import java.text.DecimalFormat;
import java.util.Scanner;
//1:无需package
//2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
int n = scan.nextInt();// 存放竹竿总数
int[] x = new int[n + 1];// 存放竹竿在x轴的位置
int[] s = new int[n + 1];// 存放竹竿间的距离，s[3]为第2根竹竿到第3根竹竿的距离
int[] y_start = new int[n + 1];// 存放竹竿传送门起点在y轴的位置
int[] y_end = new int[n + 1];// 存放竹竿传送门终点在y轴的位置
// dp[0][i]表示从起点走到第i根竹竿底部的时间，dp[1][i]表示从起点走到第i根竹竿传送门起点的时间
double[][] dp = new double[2][n + 1];
for (int i = 1; i
x[i] = scan.nextInt();
s[i] = x[i] - x[i - 1];
}
for (int i = 1; i =N时，区域1位于大矩形的左上角
if (count >= N) {
land = new int[count][2 * N];
for (int i = 0; i = count - N && j >= N) {
land[i][j] = land2[i - count + N][j - N];
}
}
}
}
// count
land = new int[2 * N - count][2 * N];
for (int i = 0; i = N - count && j 0 && land[y - 1][x] == 1) {
num += land_dfs(y - 1, x, land);
}
if (y 0 && land[y][x - 1] == 1) {
num += land_dfs(y, x - 1, land);
}
if (x
试题 G: 买二赠一
时间限制: 2.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
某商场有 N 件商品，其中第 i 件的价格是 Ai。现在该商场正在进行 “买二 赠一” 的优惠活动，具体规则是： 每购买 2 件商品，假设其中较便宜的价格是 P（如果两件商品价格一样， 则 P 等于其中一件商品的价格），就可以从剩余商品中任选一件价格不超过 P/2的商品，免费获得这一件商品。可以通过反复购买 2 件商品来获得多件免费商品，但是每件商品只能被购买或免费获得一次。 小明想知道如果要拿下所有商品（包含购买和免费获得），至少要花费多少 钱？
【输入格式】
第一行包含一个整数 N。 第二行包含 N 个整数，代表 A1, A2, A3, . . . ，AN。
【输出格式】
输出一个整数，代表答案。
【样例输入】
7
1 4 2 8 5 7 1
【样例输出】
25
【样例说明】
小明可以先购买价格 4 和 8 的商品，免费获得一件价格为 1 的商品；再后 买价格为 5 和 7 的商品，免费获得价格为 2 的商品；最后单独购买剩下的一件 价格为 1 的商品。总计花费 4 + 8 + 5 + 7 + 1 = 25。不存在花费更低的方案。
【评测用例规模与约定】
对于 30% 的数据，1 ≤ N ≤ 20。
对于 100% 的数据，1 ≤ N ≤ 5 ×
1
0
5
10^5
105，1 ≤ Ai ≤
1
0
9
10^9
109 。
【解题思路】
运用贪心算法计算，最优解为优先赠送现存最贵的商品，无法赠送时优先购买最贵的商品，以获取最大赠送金额
【代码】
package zhenti_2023_maierzengyi;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
//1:无需package
//2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
Main m = new Main();
int N = scan.nextInt();
int[] prices = new int[N];// int足以存放商品单价的大小
for (int i = 0; i = 0) {
if (!queue.isEmpty() && prices[len]
// 当队列不为空且当前商品满足免费赠送条件时，对赠送商品进行出队操作
queue.poll();
} else {
// 当当前商品无法赠送时，进行购买操作
cost += prices[len];
if (second) {
// 当商品是第二件购买的商品，符合赠送条件，入队可赠送价格
queue.add(prices[len] / 2);
second = false;
} else {
second = true;
}
}
len--;
}
return cost;
}
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 在此输入您的代码...
int N = scan.nextInt();
int[][][] min_sums = new int[3][N + 1][N + 1];// 存放不同颜色left~right区间合并的最小值
int[][] mins = new int[N + 1][N + 1];// 存放left~right区间合并的最小值
int[] nums = new int[N + 1];// 接收石子数据
int[] sums = new int[N + 1];// 存放前n堆石子数的总和
int[] clrs = new int[N + 1];// 接收颜色数据
int[][] min_nums = new int[N + 1][N + 1];// 存放left~right区间合并的最少堆数
// 为各颜色左右任意两点内的区间合并最小值赋值为int的最大值
for (int i = 1; i
for (int j = i; j
min_sums[0][i][j] = Integer.MAX_VALUE;
min_sums[1][i][j] = Integer.MAX_VALUE;
min_sums[2][i][j] = Integer.MAX_VALUE;
}
}
// 接收石子数目，并为sums赋值
for (int i = 1; i
nums[i] = scan.nextInt();
sums[i] = sums[i - 1] + nums[i];
}
// 接收颜色数据，并为石堆与自己合并值为0
for (int i = 1; i
clrs[i] = scan.nextInt();
min_sums[clrs[i]][i][i] = 0;
}
// 为区间最小堆数初始化赋值为原有堆数
for (int i = 1; i
for (int j = i; j
min_nums[i][j] = j - i + 1;
}
}
// len为区间长度
for (int len = 2; len
for (int left = 1; left
// 利用左端点和区间长度求得右端点
int right = left + len - 1;
for (int k = left; k 
还没有评论，来说两句吧...