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

小盒子可旋转，其有效尺寸组合为 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），无空间浪费。

答案总结

java 复制代码

试题 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 整除，累加符合条件的数值。

代码实现

java 复制代码

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);
    }
}

答案总结

java 复制代码

试题 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，可直接计算无需循环。

代码实现

java 复制代码

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' 并计数。

代码实现

java 复制代码

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)。

代码实现

java 复制代码

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 () 时，无需继续判断，直接退出循环。

代码实现

java 复制代码

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] 后，更新全局最大乘积。

代码实现

java 复制代码

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]。

代码实现

java 复制代码

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），减少计算量。

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