跳到主要内容
极客日志极客日志面向AI+效率的开发者社区
首页博客GitHub 精选镜像工具UI配色美学隐私政策关于联系
搜索内容 / 工具 / 仓库 / 镜像...⌘K搜索
注册
博客列表
Javajava算法

16 届蓝桥杯 Java 组省赛真题详解:思路与代码实现

2025 年第 16 届蓝桥杯软件类 Java 组省赛全题详解,涵盖试题 A 至 H。内容包括问题描述、解题思路及完整 Java 代码实现。涉及知识点包括三维空间摆放规律、等差数列求和、字符串匹配、差分优化、动态规划、栈操作及异或运算性质。适合备赛选手复盘学习,重点练习基础算法与大数据输入输出优化技巧。

星河入梦发布于 2026/3/29更新于 2026/6/1134 浏览
16 届蓝桥杯 Java 组省赛真题详解:思路与代码实现

前言

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

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


试题 A:密密摆放(5 分・结果填空)

问题描述

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

解题思路

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

  1. 小盒子可旋转,其有效尺寸组合为 30×40×50(任意维度可互换);
  2. 大箱子尺寸 200×250×240 恰好分别是小盒子 50、50、40 的 4 倍、5 倍、6 倍?不对,重新看:大箱子 200 是 40 的 5 倍,250 是 50 的 5 倍,240 是 30 的 8 倍;
  3. 组合验证:5×5×8=200 个,且体积完全匹配(200×250×240 = 200×30×40×50),无空间浪费。
答案总结
200 

试题 B:脉冲强度之和(5 分・结果填空)

问题描述

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

  1. 由连续 10 个正整数之和组成(存在 k 使 p=k+(k+1)+...+(k+9));
  2. 各个数位上的数字都相同(如 111、2222);
  3. 数值不超过 20255202。求所有符合条件的脉冲强度之和。
解题思路
  1. 条件转化:连续 10 个整数和为等差数列求和,p=10k+45,因此 p-45 必为 10 的倍数,且 p 的个位数字一定是 5;
  2. 范围筛选:符合条件的 p 只能是 5、55、555、...、55555555(个位为 5 且所有数位相同),且不超过 20255202;
  3. 验证计算:遍历所有候选数,验证是否满足 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 - ) %  == ) {
                ans += p;
            }
            
            p = p *  + ;
        }
        System.out.println(ans);
    }
}
45
10
0
// 生成下一个候选数(在末尾加 5)
10
5
答案总结
6172830 

试题 C:25 之和(10 分・编程题)

问题描述

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

输入格式

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

输出格式

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

样例输入 1
1 
样例输出 1
325 
样例输入 2
100 
样例输出 2
2800 
解题思路
  1. 直接解法:循环累加 25 个连续整数,n 最大为 10000 时,总和为 10000×25 + (0+1+...+24) = 250000 + 300 = 250300,远小于 long 类型上限,无需担心溢出;
  2. 优化解法:利用等差数列求和公式,和 = 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 
解题思路
  1. 核心规律:基础字符串为 "LANQIAO"(长度 7),每行的起始偏移量比上一行多 1(第一行偏移 0,第二行偏移 1,...,第 h 行偏移 h-1);
  2. 字符定位:对于第 i 行(0≤i<h),第 j 列(0≤j<w)的字符为基础字符串 [(i + j) % 7];
  3. 统计优化:无需生成完整矩阵,直接遍历每行每列,判断对应位置是否为 '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++) {
            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。
解题思路
  1. 暴力解法局限:直接对每次操作的 [l,r] 区间累加,时间复杂度 O(mn),无法应对 10^5 规模的数据;
  2. 差分优化原理:利用差分数组 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);
  3. 还原数列:所有操作完成后,通过差分数组前缀和计算得到最终数列,时间复杂度 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 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];
        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];
        }
        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 
解题思路
  1. 配对映射:先建立碱基配对的哈希表,如 map['A']='T'、map['T']='A' 等,快速判断碱基是否匹配;
  2. 双指针查找:对于 s 中的每个起始位置 i,用双指针 j(遍历 t)和 k(遍历 s 从 i 开始),判断 t[j] 是否与 s[k] 配对,若匹配则 j 和 k 同时后移,直到 j 遍历完 t(表示找到一个匹配);
  3. 边界处理:当 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。
解题思路
  1. 动态规划定义:设 dp[i] 表示处理前 i 个元素后,栈顶元素为序列第 i 个元素时的最大乘积(若弹出则为乘积值,若不弹出则为当前栈内元素乘积的中间状态);
  2. 状态转移:
    • 若当前元素 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(本题为正整数,无此情况):需弹出之前的元素,取当前最大乘积;
  3. 结果更新:每次计算 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 
解题思路
  1. 推导关系:根据加密规则推导原始序列与加密序列的关系:
    • 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]
  2. 求解 a[1]:将 a[n] 代入循环条件,得到关于 a[1] 的方程。由于异或运算的性质,方程有解的充要条件是 b 序列的异或和为 0(因为等式两边 a[1] 会抵消);
  3. 构造解:若有解,设 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];
        }
        if (xorSum != 0) {
            System.out.println(-1);
            return;
        }
        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 组省赛整体难度适中,主要考察以下能力:

  1. 基础语法与数据类型:如 long 类型避免溢出(试题 B、E)、输入输出优化(试题 E);
  2. 算法思维:差分优化(试题 E)、双指针(试题 F)、动态规划(试题 G)、异或性质应用(试题 H);
  3. 规律观察:填空题侧重数字规律与倍数关系(试题 A、B),减少计算量。

备考建议:重点练习等差数列求和、差分、异或等基础算法,掌握大数据输入输出优化技巧,同时注重填空题的规律分析能力,可显著提升答题效率。

目录

  1. 前言
  2. 试题 A:密密摆放(5 分・结果填空)
  3. 问题描述
  4. 解题思路
  5. 答案总结
  6. 试题 B:脉冲强度之和(5 分・结果填空)
  7. 问题描述
  8. 解题思路
  9. 代码实现
  10. 答案总结
  11. 试题 C:25 之和(10 分・编程题)
  12. 问题描述
  13. 输入格式
  14. 输出格式
  15. 样例输入 1
  16. 样例输出 1
  17. 样例输入 2
  18. 样例输出 2
  19. 解题思路
  20. 代码实现
  21. 试题 D:旗帜(10 分・编程题)
  22. 问题描述
  23. 输入格式
  24. 输出格式
  25. 样例输入
  26. 样例输出
  27. 解题思路
  28. 代码实现
  29. 试题 E:数列差分(15 分・编程题)
  30. 问题描述
  31. 输入格式
  32. 输出格式
  33. 评测用例规模与约定
  34. 解题思路
  35. 代码实现
  36. 试题 F:基因配对(15 分・编程题)
  37. 问题描述
  38. 输入格式
  39. 输出格式
  40. 样例输入
  41. 样例输出
  42. 解题思路
  43. 代码实现
  44. 试题 G:栈与乘积(20 分・编程题)
  45. 问题描述
  46. 输入格式
  47. 输出格式
  48. 评测用例规模与约定
  49. 解题思路
  50. 代码实现
  51. 试题 H:破解信息(20 分・编程题)
  52. 问题描述
  53. 输入格式
  54. 输出格式
  55. 样例输入
  56. 样例输出
  57. 解题思路
  58. 代码实现
  59. 赛后总结
  • 💰 8折买阿里云服务器限时8折了解详情
  • Magick API 一键接入全球大模型注册送1000万token查看
  • 🤖 一键搭建Deepseek满血版了解详情
  • 一键打造专属AI 智能体了解详情
极客日志微信公众号二维码

微信扫一扫,关注极客日志

微信公众号「极客日志V2」,在微信中扫描左侧二维码关注。展示文案:极客日志V2 zeeklog

更多推荐文章

查看全部
  • Java 中使用 OkHttp3 的网络请求教程与实战
  • Qwen3-VL 视觉语言模型快速部署与微调指南
  • C++ 继承:面向对象代码复用的核心机制
  • Qwen3 与 Qwen Agent 智能体开发实战:接入 MCP 工具
  • C/C++ static 关键字详解与用法总结
  • Mac 远程连接 Windows 配置指南
  • Llama-2-7B 昇腾 NPU 性能测评与部署方案
  • Axios 错误处理的设计与进阶封装,实现网络层面的数据与状态解耦
  • 机器人操作 VLA 模型强化学习综述
  • Python 代码风格指南:如何写出更 Pythonic 的代码
  • MySQL 数据库核心操作:创建、修改与备份恢复实战
  • 前端请求分层与自动接口生成方案
  • ENSP 与 LLaMA-Factory 联动构建网络运维 AI 助手
  • Ollama 本地部署教程:Windows/Linux/Mac 安装与使用指南
  • Android Studio 结合 Claude AI 快速构建 WebView 项目模板
  • AI 热榜深度解读:5 大重点方向与行业风向变化
  • Copilot 人工智能助手及编程功能介绍
  • AD4630 四通道 SPI 模式配置与采集 FPGA 设计
  • Java API 详解:基础爬虫构建与带条件数据提取
  • Google Antigravity IDE 介绍:智能体驱动开发体验

相关免费在线工具

  • Keycode 信息

    查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具,Keycode 信息在线工具,online

  • Escape 与 Native 编解码

    JavaScript 字符串转义/反转义;Java 风格 \uXXXX(Native2Ascii)编码与解码。 在线工具,Escape 与 Native 编解码在线工具,online

  • JavaScript / HTML 格式化

    使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具,JavaScript / HTML 格式化在线工具,online

  • JavaScript 压缩与混淆

    Terser 压缩、变量名混淆,或 javascript-obfuscator 高强度混淆(体积会增大)。 在线工具,JavaScript 压缩与混淆在线工具,online

  • 加密/解密文本

    使用加密算法(如AES、TripleDES、Rabbit或RC4)加密和解密文本明文。 在线工具,加密/解密文本在线工具,online

  • Gemini 图片去水印

    基于开源反向 Alpha 混合算法去除 Gemini/Nano Banana 图片水印,支持批量处理与下载。 在线工具,Gemini 图片去水印在线工具,online