当前位置：首页 > news >正文

【2025】16届蓝桥杯 Java 组全题详解（省赛真题 + 思路 + 代码）

news 2025/11/8 7:34:54

前言

试题 A：密密摆放（5 分・结果填空）

问题描述

解题思路

答案总结

试题 B：脉冲强度之和（5 分・结果填空）

问题描述

解题思路

代码实现

答案总结

试题 C：25 之和（10 分・编程题）

问题描述

输入格式

输出格式

样例输入 1

样例输出 1

样例输入 2

样例输出 2

解题思路

代码实现

试题 D：旗帜（10 分・编程题）

问题描述

输入格式

输出格式

样例输入

样例输出

解题思路

代码实现

试题 E：数列差分（15 分・编程题）

问题描述

输入格式

输出格式

评测用例规模与约定

解题思路

代码实现

试题 F：基因配对（15 分・编程题）

问题描述

输入格式

输出格式

样例输入

样例输出

解题思路

代码实现

试题 G：栈与乘积（20 分・编程题）

问题描述

输入格式

输出格式

评测用例规模与约定

解题思路

代码实现

试题 H：破解信息（20 分・编程题）

问题描述

输入格式

输出格式

样例输入

样例输出

解题思路

代码实现

赛后总结

前言

2025 年第 16 届蓝桥杯软件类 Java 组省赛已落下帷幕，不同赛区因特殊情况部分使用了备用卷，但整体题型延续了 "基础为主、梯度区分" 的特点。前两道填空题侧重规律分析，中间题型聚焦基础算法实现，后两道难题则考验数据结构与逻辑优化能力。

本文整理了 Java 组全题的详细题解，包含问题描述、核心思路、完整代码及易错点提示，所有代码均严格遵循比赛规范（类名统一为 Main），适合备赛同学复盘学习。文中答案与思路为个人解题总结，仅供参考。

试题 A：密密摆放（5 分・结果填空）

问题描述

小蓝有一个内部长宽高分别为 200、250、240 毫米的大箱子，要用它存放同样大小的小盒子（外部长宽高 30、40、50 毫米）。小盒子允许从各个方向旋转，请问最多能放多少个小盒子？

解题思路

本题核心是判断小盒子在大箱子中的三维摆放适配性，无需复杂算法，关键在于发现尺寸间的倍数关系：

小盒子可旋转，其有效尺寸组合为 30×40×50（任意维度可互换）；
大箱子尺寸 200×250×240 恰好分别是小盒子 50、50、40 的 4 倍、5 倍、6 倍？不对，重新看：大箱子 200 是 40 的 5 倍，250 是 50 的 5 倍，240 是 30 的 8 倍；
组合验证：5×5×8=200 个，且体积完全匹配（200×250×240 = 200×30×40×50），无空间浪费。

答案总结

试题 B：脉冲强度之和（5 分・结果填空）

问题描述

脉冲强度 p 需满足三个条件：

由连续 10 个正整数之和组成（存在 k 使 p=k+(k+1)+...+(k+9)）；
各个数位上的数字都相同（如 111、2222）；
数值不超过 20255202。求所有符合条件的脉冲强度之和。

解题思路

条件转化：连续 10 个整数和为等差数列求和，p=10k+45，因此 p-45 必为 10 的倍数，且 p 的个位数字一定是 5；
范围筛选：符合条件的 p 只能是 5、55、555、...、55555555（个位为 5 且所有数位相同），且不超过 20255202；
验证计算：遍历所有候选数，验证是否满足 p-45 能被 10 整除，累加符合条件的数值。

代码实现

public class Main {public static void main(String[] args) {long ans = 0L;// 生成所有个位为5且数位相同的数，上限20255202long p = 5;while (p <= 20255202) {if ((p - 45) % 10 == 0) {ans += p;}// 生成下一个候选数（在末尾加5）p = p * 10 + 5;}System.out.println(ans);}
}

答案总结

试题 C：25 之和（10 分・编程题）

问题描述

给定正整数 n，求从 n 开始的连续 25 个整数的和（n + (n+1) + ... + (n+24)）。

输入格式

输入一行包含一个正整数 n。

输出格式

输出一行包含一个整数表示答案。

样例输入 1

样例输出 1

样例输入 2

样例输出 2

解题思路

直接解法：循环累加 25 个连续整数，n 最大为 10000 时，总和为 10000×25 + (0+1+...+24) = 250000 + 300 = 250300，远小于 long 类型上限，无需担心溢出；
优化解法：利用等差数列求和公式，和 = 25×n + (24×25)/2 = 25n + 300，可直接计算无需循环。

代码实现

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();// 等差数列求和公式优化，避免循环long result = 25L * n + 300;System.out.println(result);}
}

试题 D：旗帜（10 分・编程题）

问题描述

小蓝要画一个 h×w 的矩形图形，图形规律为：第一行用 "LANQIAO" 重复填入，从第二行开始，每行向左移动一个字符，同样用 "LANQIAO" 重复填入。求图形中字母 'A' 的个数。

输入格式

输入第一行包含两个正整数 h、w，用空格分隔。

输出格式

输出一行包含一个整数表示答案。

样例输入

5 10

样例输出

解题思路

核心规律：基础字符串为 "LANQIAO"（长度 7），每行的起始偏移量比上一行多 1（第一行偏移 0，第二行偏移 1，...，第 h 行偏移 h-1）；
字符定位：对于第 i 行（0≤i<h），第 j 列（0≤j<w）的字符为基础字符串 [(i + j) % 7]；
统计优化：无需生成完整矩阵，直接遍历每行每列，判断对应位置是否为 'A' 并计数。

代码实现

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int h = sc.nextInt();int w = sc.nextInt();String base = "LANQIAO"; // 基础字符串int count = 0;for (int i = 0; i < h; i++) { // 行：偏移量为ifor (int j = 0; j < w; j++) { // 列if (base.charAt((i + j) % 7) == 'A') {count++;}}}System.out.println(count);}
}

试题 E：数列差分（15 分・编程题）

问题描述

给定一个长度为 n 的数列 a，对其进行 m 次操作，每次操作给定 l、r、v，将 a [l] 到 a [r] 之间的所有元素都加上 v（数列下标从 1 开始）。请输出经过所有操作后的数列。

输入格式

输入第一行包含两个正整数 n、m。第二行包含 n 个整数，表示初始数列 a。接下来 m 行，每行包含三个整数 l、r、v，表示一次操作。

输出格式

输出一行包含 n 个整数，表示经过所有操作后的数列。

评测用例规模与约定

对于 40% 的评测用例，1 ≤ n, m ≤ 1000；
对于所有评测用例，1 ≤ n, m ≤ 10^5，1 ≤ l ≤ r ≤ n，|v| ≤ 1000。

解题思路

暴力解法局限：直接对每次操作的 [l,r] 区间累加，时间复杂度 O (mn)，无法应对 10^5 规模的数据；
差分优化原理：利用差分数组 d，其中 d [1] = a [1]，d [i] = a [i] - a [i-1]（i>1）。对区间 [l,r] 加 v 等价于 d [l] += v、d [r+1] -= v（若 r+1≤n）；
还原数列：所有操作完成后，通过差分数组前缀和计算得到最终数列，时间复杂度 O (n+m)。

代码实现

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;public class Main {public static void main(String[] args) throws IOException {// 大数据输入需用BufferedReader优化速度BufferedReader br = new BufferedReader(new InputStreamReader(System.in));StringTokenizer st = new StringTokenizer(br.readLine());int n = Integer.parseInt(st.nextToken());int m = Integer.parseInt(st.nextToken());long[] a = new long[n + 2]; // 1-based，预留r+1位置st = new StringTokenizer(br.readLine());for (int i = 1; i <= n; i++) {a[i] = Long.parseLong(st.nextToken());}// 构建差分数组long[] diff = new long[n + 2];diff[1] = a[1];for (int i = 2; i <= n; i++) {diff[i] = a[i] - a[i - 1];}// 处理m次操作for (int i = 0; i < m; i++) {st = new StringTokenizer(br.readLine());int l = Integer.parseInt(st.nextToken());int r = Integer.parseInt(st.nextToken());long v = Long.parseLong(st.nextToken());diff[l] += v;if (r + 1 <= n) {diff[r + 1] -= v;}}// 还原数列并输出StringBuilder sb = new StringBuilder();long current = 0;for (int i = 1; i <= n; i++) {current += diff[i];sb.append(current).append(" ");}System.out.println(sb.toString().trim());}
}

试题 F：基因配对（15 分・编程题）

问题描述

基因序列由 'A'、'T'、'C'、'G' 四种碱基组成，规定配对规则为 A-T、T-A、C-G、G-C。给定两个长度分别为 n 和 m 的基因序列 s 和 t，求 t 在 s 中所有可能的匹配位置数量。匹配定义为：存在 s 的某个子序列，其长度与 t 相同，且每个位置的碱基都能与 t 对应位置配对。

输入格式

输入第一行包含字符串 s。第二行包含字符串 t。

输出格式

输出一个整数，表示匹配位置的数量。

样例输入

ATCGATC
TCG

样例输出

解题思路

配对映射：先建立碱基配对的哈希表，如 map ['A']='T'、map ['T']='A' 等，快速判断碱基是否匹配；
双指针查找：对于 s 中的每个起始位置 i，用双指针 j（遍历 t）和 k（遍历 s 从 i 开始），判断 t [j] 是否与 s [k] 配对，若匹配则 j 和 k 同时后移，直到 j 遍历完 t（表示找到一个匹配）；
边界处理：当 s 剩余长度（s.length ()-i）小于 t.length () 时，无需继续判断，直接退出循环。

代码实现

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String s = sc.next();String t = sc.next();int n = s.length();int m = t.length();if (m > n) {System.out.println(0);return;}// 建立配对映射Map<Character, Character> pairMap = new HashMap<>();pairMap.put('A', 'T');pairMap.put('T', 'A');pairMap.put('C', 'G');pairMap.put('G', 'C');int count = 0;// 遍历所有可能的起始位置for (int i = 0; i <= n - m; i++) {boolean match = true;for (int j = 0; j < m; j++) {char target = pairMap.get(t.charAt(j));if (s.charAt(i + j) != target) {match = false;break;}}if (match) {count++;}}System.out.println(count);}
}

试题 G：栈与乘积（20 分・编程题）

问题描述

给定一个包含 n 个正整数的序列，将其依次压入栈中，在压栈过程中可以随时弹出元素。要求弹出的元素序列的乘积尽可能大，且弹出序列必须是非空的。求这个最大乘积。

输入格式

输入第一行包含一个正整数 n。第二行包含 n 个正整数，表示序列。

输出格式

输出一个整数，表示最大乘积。

评测用例规模与约定

对于 30% 的评测用例，1 ≤ n ≤ 10；
对于所有评测用例，1 ≤ n ≤ 1000，序列元素均不超过 10。

解题思路

动态规划定义：设 dp [i] 表示处理前 i 个元素后，栈顶元素为序列第 i 个元素时的最大乘积（若弹出则为乘积值，若不弹出则为当前栈内元素乘积的中间状态）；
状态转移：
- 若当前元素 x>1：dp [i] = dp [i-1] * x（若 dp [i-1] 存在且 > 0）或 x（若 dp [i-1]≤0 或 i=1）；
- 若当前元素 x=1：由于 1 不增加乘积，可选择不弹出，dp [i] = dp [i-1]（若 dp [i-1] 存在）或 1；
- 若当前元素 x<1（本题为正整数，无此情况）：需弹出之前的元素，取当前最大乘积；
结果更新：每次计算 dp [i] 后，更新全局最大乘积。

代码实现

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();int[] arr = new int[n];for (int i = 0; i < n; i++) {arr[i] = sc.nextInt();}long[] dp = new long[n];long maxProduct = arr[0];dp[0] = arr[0];for (int i = 1; i < n; i++) {int x = arr[i];// 状态转移：选择与前一个栈顶乘积结合，或单独作为新的栈顶if (dp[i-1] > 1) {dp[i] = dp[i-1] * x;} else {dp[i] = x;}// 更新最大乘积if (dp[i] > maxProduct) {maxProduct = dp[i];}}System.out.println(maxProduct);}
}

试题 H：破解信息（20 分・编程题）

问题描述

一条加密信息由 n 个非负整数组成，加密规则为：对于每个位置 i（1≤i≤n），加密后的值 b [i] = a [i] XOR a [i+1]（其中 a [n+1] = a [1]，即循环异或）。给定加密后的序列 b，求原始序列 a 的任意一个可能解。若不存在解，则输出 - 1。

输入格式

输入第一行包含一个正整数 n。第二行包含 n 个整数，表示加密序列 b。

输出格式

输出一行包含 n 个整数，表示原始序列 a。若无解，输出 - 1。

样例输入

3
1 2 3

样例输出

0 1 3

解题思路

推导关系：根据加密规则推导原始序列与加密序列的关系：
- a[2] = a[1] XOR b[1]
- a[3] = a[2] XOR b[2] = a[1] XOR b[1] XOR b[2]
- ...
- a[n] = a[1] XOR b[1] XOR b[2] XOR ... XOR b[n-1]
- 循环条件：a [1] = a [n] XOR b [n]
求解 a [1]：将 a [n] 代入循环条件，得到关于 a [1] 的方程。由于异或运算的性质，方程有解的充要条件是 b 序列的异或和为 0（因为等式两边 a [1] 会抵消）；
构造解：若有解，设 a [1] = 0（或任意值），根据上述推导公式计算出所有 a [i]。

代码实现

import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();int[] b = new int[n];int xorSum = 0;for (int i = 0; i < n; i++) {b[i] = sc.nextInt();xorSum ^= b[i];}// 无解条件：异或和不为0if (xorSum != 0) {System.out.println(-1);return;}// 构造解，设a[0] = 0（对应a[1]）int[] a = new int[n];a[0] = 0;int prefixXor = 0;for (int i = 1; i < n; i++) {prefixXor ^= b[i-1];a[i] = a[0] ^ prefixXor;}// 输出结果StringBuilder sb = new StringBuilder();for (int num : a) {sb.append(num).append(" ");}System.out.println(sb.toString().trim());}
}