2024年十五届蓝桥杯省赛大学B组真题（Java残缺版）_蓝桥杯题目

2024年十五届蓝桥杯省赛大学B组真题（Java）

前言：

赛后一直犹豫要不要对比赛进行复盘出个题解，拖到了现在，终于也是等到比赛结果出来，看到没有辜负个人期望成功取得省一，决定在国赛前对省赛进行一个复盘，顺带查漏补缺，总体而言，这次JavaB组的省赛题偏基础，没有太多的算法，也是延续了暴力杯的头衔，这次对数学的考察居然比以往提高了不少，令我感到意外，题外话不多说，让我们一起来复盘一下第十五届的省赛题吧，同时也祝愿各位能取得一个不错的成绩。
（未完篇）

题单链接

点击此处跳转

试题A：报数游戏

本题总分：5 分

【问题描述】

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：2429042904288

【解题思路】

该题数据量大，单纯靠电脑跑不太现实，那么其中肯定有数学规律在，通过计算可以得出 20 和 24 的最小公倍数是 120 ，再对符合条件的前四十个数进行输出，我们可以发现该规律是十次一循环，每次结尾都是 120 的倍数，那么我们可以求得第 202420242020 个数的值为 202420242020/10*120=2429042904240 ，再通过观察发现第四个数与上一个循环相差 48 ，把两个数值相加得到答案 2429042904288

【代码】

package SS2024b.baoshuyouxi;

public class Main {
	public static void main(String[] args) {
		long n = 202420242024L;
//		long count = 0;
//		for (long i = 1; count < 40; i++) {
//			if (i * 4 % 20 == 0 || i * 4 % 24 == 0) {
//				count++;
//				System.out.println(i * 4);
//			}
//		}
		long num1 = (n - 4) / 10 * 120;
		long num2 = 48;
		long num = num1 + num2;
		System.out.println(num);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

试题 B: 类斐波那契循环数

本题总分：5 分

【问题描述】

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案：7913837

【解题思路】

给出一个判断是否为类斐波那契循环数的判断式，该判断式类似于滚动窗口，固定取一个窗口大小，该大小为 n 的值，维护窗口内所有值的和 sum ，判断 sum 在小于等于 n 是是否存在相等的情况即可，从 1e7 开始一直递减遍历下去，遇到的第一个符合条件的数即为答案。

【代码】

package SS2024b.leifeibonaqixunhuan;

import java.util.ArrayList;

public class Main {
	public static void main(String[] args) {
		int l = (int) 1e7;
		while (l > 0) {
			if (isLei(l)) {
				System.out.println(l);
				break;
			}
			l--;
		}
	}

	static boolean isLei(int n) {
		boolean flag = false;
		int n1 = n;
		ArrayList<Integer> ys = new ArrayList<Integer>();
		while (n1 != 0) {
			ys.add(n1 % 10);
			n1 /= 10;
		}
		ArrayList<Integer> s = new ArrayList<Integer>();
		s.add(0);
		int sum = 0;
		for (int i = ys.size() - 1; i >= 0; i--) {
			s.add(ys.get(i));
			sum += ys.get(i);
		}

		int index = 0;
		while (sum <= n) {
			if (index != 0) {
				sum *= 2;
			}
			s.add(sum -= s.get(index++));
			if (sum == n) {
				flag = true;
				break;
			}
		}
		return flag;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

试题 C: 分布式队列

时间限制: 3.0s 内存限制: 512.0MB 本题总分：10 分

【问题描述】

【输入格式】

【输出格式】

对于每一个 query 操作，输出一行，包含一个整数表示答案。

【样例输入】

3
add 1
add 2
query
add 1
sync 1
sync 1
sync 2
query
sync 1
query
sync 2
sync 2
sync 1
query
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

【样例输出】

0
1
1
3
1
2
3
4

【样例说明】

【评测用例规模与约定】

【解题思路】

该题只需要使用队列或者集合来模拟该操作过程以及掌握不断获取输入数据的操作，在每次进行查询操作时，输出最短的队列长度即为答案。

【代码】

package SS2024b.fenbushiduilie;

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		ArrayList<Integer>[] list = new ArrayList[n];
		for (int i = 0; i < n; i++) {
			list[i] = new ArrayList<Integer>();
		}
		while (scan.hasNext()) {
			String cz = scan.next();
			if (cz.equals("add")) {
				int element = scan.nextInt();
				list[0].add(element);
			} else if (cz.equals("sync")) {
				int follower_id = scan.nextInt();
				if (list[0].size() != list[follower_id].size()) {
					list[follower_id].add(list[0].get(list[follower_id].size()));
				}

			} else if (cz.equals("query")) {
				int min = list[0].size();
				for (int i = 1; i < n; i++) {
					min = Math.min(min, list[i].size());
				}
				System.out.println(min);
			}
		}
		scan.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

试题 D: 食堂

时间限制: 3.0s 内存限制: 512.0MB 本题总分：10 分

【问题描述】

【输入格式】

【输出格式】

输出共 q 行，每行一个整数表示对应输入数据的答案。

【样例输入】

2
3 0 1 0 1
0 2 2 1 1
1
2
3

【样例输出】

6
10
1
2

【样例说明】

【评测用例规模与约定】

【解题思路】

本题是求最大满足人数，一开始我想到的是背包问题求解，测试用例只通过了三个，后来发现题目数据量较小，可以直接进行枚举求解，尝试了好几回，一样是只通过三个测试用例，暂时出不了这题的题解，只能先发一下代码，希望各位大佬能帮忙纠正一下

【代码】

package SS2024b.shitang;

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int q = scan.nextInt();
		while (q-- > 0) {
			int a2 = scan.nextInt();
			int a3 = scan.nextInt();
			int a4 = scan.nextInt();
			int b4 = scan.nextInt();
			int b6 = scan.nextInt();
			int sum = 0;
			// 优先分配四人桌
			if (b4 != 0) {
				// 四人寝
				int num_4 = 0;
				if (b4 != 0 && a4 != 0) {
					// 获取最多可以分配的四人桌数量
					int count = Math.min(a4, b4);
					num_4 = count * 4;
					a4 -= count;
					b4 -= count;
				}
				// 两人寝*2
				int num_22 = 0;
				if (b4 != 0 && a2 != 0 && a2 / 2 != 0) {
					// 获取最多可以分配的四人桌数量
					int count = Math.min(a2 / 2, b4);
					num_22 = count * 4;
					a2 -= count * 2;
					b4 -= count;
				}
				// 三人寝
				int num_3 = 0;
				if (b4 != 0 && a3 != 0) {
					// 获取最多可以分配的四人桌数量
					int count = Math.min(a3, b4);
					num_3 = count * 3;
					a3 -= count;
					b4 -= count;
				}
				// 两人寝
				int num_2 = 0;
				if (b4 != 0 && a2 != 0) {
					// 获取最多可以分配的四人桌数量
					int count = Math.min(a2, b4);
					num_2 = count * 2;
					a2 -= count;
					b4 -= count;
				}
				sum += num_4 + num_22 + num_3 + num_2;
			}
			// 贪心分配剩下的六人桌
			if (b6 != 0) {
				// 四人寝+两人寝室
				int num_42 = 0;
				if (b6 != 0 && a4 != 0 && a2 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a4, Math.min(a2, b6));
					num_42 = count * 6;
					b6 -= count;
					a2 -= count;
					a4 -= count;
				}
				// 三人寝*2
				int num_33 = 0;
				if (b6 != 0 && a3 != 0 && a3 / 2 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a3 / 2, b6);
					num_33 = count * 6;
					b6 -= count;
					a3 -= count * 2;
				}
				// 两人寝*3
				int num_222 = 0;
				if (b6 != 0 && a2 != 0 && a2 / 3 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a2 / 3, b6);
					num_222 = count * 6;
					b6 -= count;
					a2 -= count * 3;
				}
				// 三人寝+两人寝
				int num_32 = 0;
				if (b6 != 0 && a3 != 0 && a2 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a3, Math.min(a2, b6));
					num_32 = count * 5;
					b6 -= count;
					a2 -= count;
					a3 -= count;
				}
				// 四人寝
				int num_4 = 0;
				if (b6 != 0 && a4 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a4, b6);
					num_4 = count * 4;
					b6 -= count;
					a4 -= count;
				}
				// 两人寝*2
				int num_22 = 0;
				if (b6 != 0 && a2 != 0 && a2 / 2 != 0) {
					int count = Math.min(a2 / 2, b6);
					num_22 = count * 4;
					b6 -= count;
					a2 -= count * 2;
				}
				// 三人寝
				int num_3 = 0;
				if (b6 != 0 && a3 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a3, b6);
					num_3 = count * 3;
					b6 -= count;
					a3 -= count;
				}
				// 两人寝
				int num_2 = 0;
				if (b6 != 0 && a2 != 0) {
					// 获取最多可以分配的六人桌数量
					int count = Math.min(a2, b6);
					num_2 = count * 2;
					b6 -= count;
					a2 -= count;
				}
				sum += num_42 + num_33 + num_222 + num_32 + num_4 + num_22 + num_3 + num_2;
			}
			System.out.println(sum);
		}
		scan.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

试题 E: 最优分组

时间限制: 3.0s 内存限制: 512.0MB 本题总分：15 分

【问题描述】

【输入格式】

第一行，一个整数 N。
第二行，一个浮点数 p。

【输出格式】

输出一行，一个整数 K 表示答案。

【样例输入】

1000
0.05
1
2

【样例输出】

5
1

【样例说明】

无

【评测用例规模与约定】

【解题思路】

本题是求解数学期望值，最大期望用试剂量为 N ，分成每组 k 只宠物后，生病概率为 1-(1-p)${}^k$ ，固定要使用的试剂量为 n/k ，如果一组宠物生病的额外用试剂量为 k ，生病的总用试剂量为 k*[1-(1-p)${}^k$]n/k ,则总的期望用试剂量为 k[1-(1-p)${}^k$]*n/k+n/k 利用该式可求得最小期望值所代表的 k 。

【代码】

package SS2024b.zuiyoufenzu;

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n = scan.nextInt();
		double p = scan.nextDouble();
		double min = 1.0 * n;
		int min_index = 1;
		for (int k = 1; k <= n; k++) {
			if (n % k == 0) {
				double num = k * (1 - Math.pow(1 - p, k)) * n / k + n / k;
				if (num < min) {
					min = num;
					min_index = k;
				}
			}
		}
		System.out.println(min_index);
		scan.close();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

试题 F: 星际旅行

时间限制: 3.0s 内存限制: 512.0MB 本题总分：15 分

【问题描述】

【输入格式】

【输出格式】

输出共一行，一个浮点数（四舍五入保留两位小数）。

【样例输入】

3 2 3
1 2
2 3
2 1
2 0
1 1
1
2
3
4
5
6

【样例输出】

2.00
1

【样例说明】

【评测用例规模与约定】

【解题思路】

【代码】

1

试题 G: LITS游戏

时间限制: 3.0s 内存限制: 512.0MB 本题总分：20 分

【问题描述】

【输入格式】

【输出格式】

对于每组数据，输出一行包含一个字符串。如果此组数据满足题意则输出“Yes”，否则输出 “No”。

【样例输入】

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

【样例输出】

No
Yes
1
2

【样例说明】

【评测用例规模与约定】

【解题思路】

【代码】

1

试题 H: 拼十字

时间限制: 3.0s 内存限制: 512.0MB 本题总分：20 分

【问题描述】

【输入格式】

第一行一个整数 N，表示有 N 个矩形。接下来 N 行，每行输入三个整数 l、w、c 表示一个矩形的长、宽和颜色。

【输出格式】

输出一个整数表示答案。由于答案可能会很大，所以你需要将答案对$10^9$ + 7 取模之后输出。

【样例输入】

5
1 10 0
6 6 0
8 6 1
6 10 0
1 2 1
1
2
3
4
5
6

【样例输出】

2
1

【样例说明】

第 3 个矩形可以和第 1 个矩形拼十字，第 3 个矩形也可以和第 4 个矩形拼十字。所以一共有两对矩形可以拼十字，答案为 2。

【评测用例规模与约定】

对于 30% 的评测用例：1 ≤ N ≤ 5000。
对于 100% 的评测用例：1 ≤ N ≤ $10^5$，1 ≤ l,w ≤ $10^5$，0 ≤ c ≤ 2。

【解题思路】

【代码】

1