【2025】16届蓝桥杯 Java 组全题详解（省赛真题 + 思路 + 代码）
目录
前言
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），无空间浪费。
答案总结
200 试题 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且数位相同的数，上限20255202 long p = 5; while (p <= 20255202) { if ((p - 45) % 10 == 0) { ans += p; } // 生成下一个候选数（在末尾加5） p = p * 10 + 5; } System.out.println(ans); } } 答案总结
6172830 试题 C：25 之和（10 分・编程题）
问题描述
给定正整数 n，求从 n 开始的连续 25 个整数的和（n + (n+1) + ... + (n+24)）。
输入格式
输入一行包含一个正整数 n。
输出格式
输出一行包含一个整数表示答案。
样例输入 1
1 样例输出 1
325 样例输入 2
100 样例输出 2
2800 解题思路
- 直接解法：循环累加 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 样例输出
14 解题思路
- 核心规律：基础字符串为 "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++) { // 行：偏移量为i for (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 样例输出
2 解题思路
- 配对映射：先建立碱基配对的哈希表，如 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]; } // 无解条件：异或和不为0 if (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()); } } 赛后总结
2025 年 Java 组省赛整体难度适中，主要考察以下能力：
- 基础语法与数据类型：如 long 类型避免溢出（试题 B、E）、输入输出优化（试题 E）；
- 算法思维：差分优化（试题 E）、双指针（试题 F）、动态规划（试题 G）、异或性质应用（试题 H）；
- 规律观察：填空题侧重数字规律与倍数关系（试题 A、B），减少计算量。
备考建议：重点练习等差数列求和、差分、异或等基础算法，掌握大数据输入输出优化技巧，同时注重填空题的规律分析能力，可显著提升答题效率。
