2025第十六届蓝桥杯JavaB组个人题解（题目全）

已于 2025-04-30 15:25:46 修改
阅读量2k 收藏 15
点赞数 26
文章标签： 蓝桥杯 算法 java
于 2025-04-12 15:44:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NingMaoKing/article/details/147165150
版权

蓝桥杯 2025 Java B 组题解（省赛）

第一次参加蓝桥杯。用的是 BufferedReader + PrintWriter 做输入输出，担心超时或者低级错误（比如 Main 打成 Mian）。

次日更新，刚考完蜜汁自信，想着省一应该稳了，对完答案发现，填空全错，答题t到吐，大概15到20来分，省二估计都悬了，好好沉淀吧，大二奔国赛！

4月30更新，省二上游(按整页算是第二页尾），考完笑嘻嘻，对完答案哭唧唧，第一题如果没改错应该就是省一

一、填空题

A. 立方和的个位数为 3 的数有几个？

思路

遍历 1~2025，每个数求立方，检查个位是不是 3。题目简单，我本来做对了，结果最后改错了（最后两分钟不开long重写一次，被自己蠢笑了），血亏 5 分。

Java代码
public class lan2025 {
    public static void main(String[] args) {
        int count = 0;
        for (long i = 1; i <= 2025; i++) {
            if (i * i * i % 10 == 3) {
                count++;
            }
        }
        System.out.println(count); // 答案是 202
    }
}
答案
202

B. 蓝宝不见了

题目条件

设 N 是蓝宝出现时间，满足：

  1. N + 20250412 能被 20240413 整除
  2. N + 20240413 能被 20250412 整除
  3. 求最小N
思路

我的思路是
在这里插入图片描述
中国剩余定理也可以做，可以当做扩展。

Java代码
public class lan2025 {
    public static void main(String[] args) {
        int x = 20250412, y = 20240413;
        int c = x - y;
        for (int i = 1; i < 100000000; i++) {
            if (((x - c) * i - c) % x == 0) {
                long N = (long) (x - c) * i - x;
                System.out.println(N); // 答案
                break;
            }
        }
    }
}

更新：这里给出正确解答的方法

由题意可知，我们可以得出关系式：①N=a×20250412−20240413=b×20240413−20250412，其中 a 与 b 均为正整数。
我们将他进行移项，我们即可得出关系式：②(a+1)×20250412=(b+1)×20240413。
根据辗转相除法，20250412 与 20240413 最大公约数是 1。
那么他们两个的最大公约数是他们的乘积。也就是说，关系式 ② 中我们很容易得出 a=20240412 并 b=20250411 ,我们也就可以从 a 或 b 的值带入 ① 关系式即可。 也就是 20240412×20250412−20240413=409876661809331 或者是 20250411×20240413−20250412=409876661809331。
综上所述，最后的答案是 409876661809331。

答案
780002974133831（个人求解结果）
409876661809331 （正确解）

二、编程题

C. 电池分组（异或分组）

题目概述

研究员小蓝受到实验室主任的指示，需要对实验室新研发的 N N N 个新型能量电池进行分组实验。这 N N N 个能量电池的能量值分别用 A 1 , A 2 , … , A N A_1, A_2, \dots , A_N A1​,A2​,…,AN​ 表示，每个能量值都是一个整数。为了保证实验的安全性，小蓝需要将这 N N N 个能量电池分成两组，使得这两组能量电池的能量值异或和相等。

能量值的异或和计算方法如下：对于一个集合 S S S，其异或和等于集合中所有元素的按位异或结果。例如，集合 { 1 , 2 , 3 } \{1, 2, 3\} {1,2,3} 的异或和为 1 ⊕ 2 ⊕ 3 = 0 1 \oplus 2 \oplus 3 = 0 1⊕2⊕3=0，其中 ⊕ \oplus ⊕ 表示异或运算。

现在，小蓝想知道，这 N N N 个能量电池能否分成两组，使得这两组能量电池的能量值异或和相等。注意，每组至少包含一个能量电池。

输入格式

输入的第一行包含一个整数 T T T，表示测试用例的数量。

每个测试用例占两行：

  • 第一行包含一个整数 N N N，表示能量电池的数量。
  • 第二行包含 N N N 个整数 A 1 , A 2 , … , A N A_1, A_2, \dots , A_N A1​,A2​,…,AN​，表示每个能量电池的能量值。
输出格式

对于每个测试用例，输出一行。如果可以将能量电池分成两组，使得这两组能量电池的能量值异或和相等，则输出 YES；否则，输出 NO。

输入输出样例 #1
输入 #1
2
3
1 2 3
4
1 2 3 4
输出 #1
YES
NO
解题思路

其实整组异或和为 0，就能分组成功（至少两组），不需要暴力回溯。

正确解法（简洁版）
public class Main {
    public static void main(String[] args) throws Exception {
        var br = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        while (T-- > 0) {
            int n = Integer.parseInt(br.readLine());
            String[] parts = br.readLine().split(" ");
            int xor = 0;
            for (String s : parts) xor ^= Integer.parseInt(s);
            System.out.println(xor == 0 ? "YES" : "NO");
        }
    }
}
  • 我是回溯，就过了一个用例
package lanqiao.lan2025;

import java.io.*;
import java.util.HashSet;
import java.util.Set;

public class q3 {
    static BufferedReader br  = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
        int t = Integer.parseInt(br.readLine());
        for(int i = 0;i<t;i++){
            int n = Integer.parseInt(br.readLine());
            int[] ans = new int[n];
            String[] s = br.readLine().split(" ");
            for(int j = 0;j<n;j++){
                ans[j] = Integer.parseInt(s[j]);
            }
            if(dfs(ans,0,new HashSet<>())){
                pw.println("YES");
            }else{
                pw.println("NO");
            }
        }
        pw.flush();
    }
    
    private static boolean dfs(int[] ans, int start, Set<Integer> set){
        if(start==ans.length){
            if(!set.isEmpty()){
                int a = 0;
                int b = 0;
                for(int i = 0;i<ans.length;i++){
                    if(set.contains(i)){
                        a^=ans[i];
                    }else{
                        b^=ans[i];
                    }
                }
                if(a==b) {
                    return true;
                }
            }
            return false;
        }
        
        boolean no = dfs(ans,start+1,set);
        
        set.add(start);
        boolean yes = dfs(ans,start+1,set);
        set.remove(start);
        return yes||no;
    }
}

D. 魔法科考试（有效魔法种类数）

题目描述

小明正在参加魔法科的期末考试，考生需要根据给定的口诀组合出有效的魔法。其中，老师给定了 n n n 个上半部分口诀 a 1 , a 2 , … , a n a_1, a_2, \dots , a_n a1​,a2​,…,an​ 和 m m m 个下半部分口诀 b 1 , b 2 , … , b m b_1, b_2, \dots , b_m b1​,b2​,…,bm​，均用整数表示。完整的口诀包含一个上半部分口诀和一个下半部分口诀，当选用两个口诀 a i a_i ai​ 和 b j b_j bj​，将组合出完整口诀 S = a i + b j S = a_i + b_j S=ai​+bj​。

当 S S S 满足 S ≤ n + m S \leq n + m S≤n+m 且 S S S 为质数时，魔法是有效的。魔法的种类只和 S S S 的大小有关。如果每个上半部分口诀和每个下半部分口诀在不同的组合中可以重复使用，小明想知道一共可能组合出多少种不同的有效魔法？

思路
  • 枚举所有 a + b。
  • 若结果在 1 ~ (n + m) 范围内，且为质数，则是有效魔法。
  • 用 Set 去重。
优化点
  • 用布尔数组先筛出所有小于等于 n + m 的质数（埃氏筛）。
输入格式

输入共三行。

  • 第一行为两个正整数 n , m n, m n,m。
  • 第二行为 n n n 个由空格分开的正整数 a 1 , a 2 , … , a n a_1, a_2, \dots , a_n a1​,a2​,…,an​。
  • 第三行为 m m m 个由空格分开的正整数 b 1 , b 2 , … , b m b_1, b_2, \dots , b_m b1​,b2​,…,bm​。
输出格式

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

输入输出样例 #1
输入 #1
3 4
2 3 10
3 4 5 1
输出 #1
3
Java代码
import java.io.*;
import java.util.*;

public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    static boolean[] isPrime;

    public static void main(String[] args) throws IOException {
        String[] s = br.readLine().split(" ");
        int n = Integer.parseInt(s[0]);
        int m = Integer.parseInt(s[1]);
        int[] A = new int[n];
        int[] B = new int[m];

        String[] s1 = br.readLine().split(" ");
        String[] s2 = br.readLine().split(" ");
        for (int i = 0; i < n; i++) A[i] = Integer.parseInt(s1[i]);
        for (int i = 0; i < m; i++) B[i] = Integer.parseInt(s2[i]);

        int maxSum = n + m;
        sieve(maxSum);

        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                int sum = A[i] + B[j];
                if (sum <= maxSum && isPrime[sum]) {
                    set.add(sum);
                }
            }
        }

        pw.println(set.size());
        pw.flush();
    }

    static void sieve(int max) {
        isPrime = new boolean[max + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        for (int i = 2; i * i <= max; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= max; j += i) {
                    isPrime[j] = false;
                }
            }
        }
    }
}
  • 这里我又傻呗了，本来是打算用埃式筛，后面想想我的也应该不慢，又是t到吐，还是别太懒，不然这题拿下省一就还是有希望

import java.io.*;

public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
       String[] s = br.readLine().split(" ");
       int n = Integer.parseInt(s[0]);
       int m = Integer.parseInt(s[1]);
       int[] ans1 = new int[n];
       int[] ans2 = new int[m];
       String[] s1 = br.readLine().split(" ");
       String[] s2 = br.readLine().split(" ");
       for(int i = 0;i<n;i++){
           ans1[i] = Integer.parseInt(s1[i]);
       }
        for(int i = 0;i<m;i++){
            ans2[i] = Integer.parseInt(s2[i]);
        }
       
       int count = 0;
       for(int i = 0;i<n;i++){
           for(int j = 0;j<m;j++){
               if(ans1[i]+ans2[j]<=n+m&&is(ans1[i]+ans2[j])){
                    count++;
               }
           }
       }
       pw.println(count);
       pw.flush();
    }
    
    private static boolean is(int n){
        if(n<=1){
            return false;
        }
        if(n<=3){
            return true;
        }
        if(n%2==0||n%3==0){
            return false;
        }
        for(int i = 5;i*i<=n;i+=6){
            if(n%i==0||n%(i+2)==0){
                return false;
            }
        }
        return true;
    }
}

E. 爆破（最小生成树）

题目描述

小明正在参加一场爆破工作。人们在地面上放置了 n n n 个爆炸魔法阵，第 i i i 个魔法阵的圆心坐标为 ( x i , y i ) (x_i, y_i) (xi​,yi​)，半径为 r i r_i ri​。如果两个魔法阵相交，则它们可以一起引爆；如果两个魔法阵不相交，则可以再使用一条魔法回路将它们的边缘连接起来。小明想知道最少需要布置总长度多长的魔法回路才能使得所有的魔法阵可以一起引爆？

思路

其实就是找到能连通全部的一条线，我用的floyd哈哈哈哈哈，一样的t到吐

输入格式

输入共 n + 1 n + 1 n+1 行。

  • 第一行为一个正整数 n n n。
  • 后面 n n n 行，每行三个整数表示 x i , y i , r i x_i, y_i, r_i xi​,yi​,ri​。
输出格式

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

输入输出样例 #1
输入 #1
4
0 0 1
2 0 2
-3 0 1
4 4 1
输出 #1
2.47
Java代码（floyd，纯暴力，t吐）
import java.io.*;
import java.util.Arrays;

public class Main {
    static BufferedReader br  = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine());
        double[][] grid = new double[n][n];
        double INF = 1e18; // 更安全的极大值

        for (double[] row : grid) {
            Arrays.fill(row, INF);
        }

        int[][] circles = new int[n][3];
        for (int i = 0; i < n; i++) {
            String[] s = br.readLine().split(" ");
            int x = Integer.parseInt(s[0]);
            int y = Integer.parseInt(s[1]);
            int r = Integer.parseInt(s[2]);
            circles[i] = new int[]{x, y, r};
        }

        for (int i = 0; i < n; i++) {
            grid[i][i] = 0;
            for (int j = i + 1; j < n; j++) {
                int dx = circles[i][0] - circles[j][0];
                int dy = circles[i][1] - circles[j][1];
                double dist = Math.sqrt(dx * dx + dy * dy);
                double cost = Math.max(0, dist - circles[i][2] - circles[j][2]);
                grid[i][j] = cost;
                grid[j][i] = cost;
            }
        }

        // Floyd-Warshall with overflow check
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (grid[i][k] < INF && grid[k][j] < INF) {
                        grid[i][j] = Math.min(grid[i][j], grid[i][k] + grid[k][j]);
                    }
                }
            }
        }

        double max = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                max = Math.max(max, grid[i][j]);
            }
        }

        pw.printf("%.02f\n", max); // 输出保留10位小数，防止精度误差
        pw.flush();
    }
}

F. 数组翻转最大得分

题目描述

小明生成了一个长度为 n n n 的正整数数组 a 1 , a 2 , … , a n a_1, a_2, \dots , a_n a1​,a2​,…,an​，他可以选择连续的一段数 a l , a l + 1 , … , a r a_l, a_{l+1}, \dots, a_r al​,al+1​,…,ar​，如果其中所有数都相等即 a l = a l + 1 = ⋯ = a r a_l = a_{l+1} = \dots = a_r al​=al+1​=⋯=ar​，那么他可以获得 ( r − l + 1 ) × a l (r - l + 1) \times a_l (r−l+1)×al​ 的分数。

在选择之前，为了让分数尽可能大，他决定先选择数组中的一段区间，对其进行左右翻转。他想知道在对数组进行翻转之后他能获得的最大分数是多少？

提示：当翻转 a l a_l al​ 到 a r a_r ar​ 这段区间后，整个数组会变为：

a 1 , a 2 , … , a l − 1 , a r , a r − 1 , … , a l + 1 , a l , a r + 1 , … , a n a_1, a_2, \dots , a_{l-1}, a_r, a_{r-1}, \dots , a_{l+1}, a_l, a_{r+1}, \dots , a_n a1​,a2​,…,al−1​,ar​,ar−1​,…,al+1​,al​,ar+1​,…,an​

输入格式

输入共两行。

  • 第一行为一个正整数 n n n。
  • 第二行为 n n n 个由空格分开的正整数 a 1 , a 2 , … , a n a_1, a_2, \dots , a_n a1​,a2​,…,an​。
输出格式

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

输入输出样例 #1
输入 #1
7
4 4 3 3 2 1 3
输出 #1
9
Java暴力代码（t到吐）：

import java.io.*;

public class Main {
    static BufferedReader br  = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    
    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine());
        String[] s = br.readLine().split(" ");
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            ans[i] = Integer.parseInt(s[i]);
        }
        
        int maxArea = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int[] copy = ans.clone();
                // reverse [i...j]
                for (int l = 0; l <= (j - i) / 2; l++) {
                    int temp = copy[i + l];
                    copy[i + l] = copy[j - l];
                    copy[j - l] = temp;
                }
                maxArea = Math.max(maxArea, max(copy));
            }
        }
        
        pw.println(maxArea);
        pw.flush();
    }
    
    private static int max(int[] arr) {
        int max = 0;
        int i = 0;
        while (i < arr.length) {
            int j = i;
            while (j < arr.length && arr[j] == arr[i]) j++;
            max = Math.max(max, (j - i) * arr[i]);
            i = j;
        }
        return max;
    }
}

G. 2 的幂的倍数（最小加和）

题目描述

小明很喜欢 2 2 2 的幂，所以他想对一个长度为 n n n 的正整数数组 { a 1 , a 2 , … , a n } \{a_1, a_2, \dots, a_n\} {a1​,a2​,…,an​} 进行改造。他可以进行如下操作任意多次（可以是 0 0 0 次）：任选一个数 a i a_i ai​ 加上任意正整数，但不能使得加完之后的结果超过 1 0 5 10^5 105。

在操作任意次后，小明希望所有数的乘积是 2 k 2^k 2k 的倍数。他想知道总共需要加的数的总和至少是多少？

输入格式

输入共两行。

  • 第一行为两个正整数 n , k n, k n,k。
  • 第二行为 n n n 个由空格分开的正整数 a 1 , a 2 , … , a n a_1, a_2, \dots, a_n a1​,a2​,…,an​。
输出格式

输出共 1 1 1 行，一个整数表示答案。如果不能满足条件，输出 − 1 -1 −1。

输入输出样例 #1
输入 #1
3 9
19 10 3
输出 #1
12
Java代码
  • 比赛中我也是回溯暴力，不说了，说多都是累，而且我的还过不了用例，这里就不展示了

H. 研发资源分配最大差值（田忌赛马）

题目描述

在蓝桥科技公司， A A A 部门和 B B B 部门正在竞争一种新型 AI 芯片的研发资源。

为了公平分配资源，公司设计了一个为期 N N N 天的分配方案：

每天早上， A A A 部门和 B B B 部门各自提交一个需求等级（从 1 1 1 到 N N N 的整数）。提交等级较高的部门获得当天的资源，资源份额等于当天的日期编号（第 1 1 1 天为 1 1 1 单位，第 2 2 2 天为 2 2 2 单位，依次递增）。若两部门提交的等级相同，则当天资源作废，双方均无法获得资源。

每个部门必须在 N N N 天内使用 1 1 1 到 N N N 的所有等级，且每个等级只能使用一次。

有趣的是， A A A 部门在 B B B 部门内部安插了一名 “间谍”，提前获知了 B B B 部门的需求等级提交顺序，记为排列 ( P 1 , P 2 , … , P N P_1, P_2, \dots , P_N P1​,P2​,…,PN​)，其中 P i P_i Pi​ 表示 B B B 部门在第 i i i 天提交的需求等级。

现在，请你帮助 A A A 部门分析，在已知 B B B 部门需求等级顺序的情况下， A A A 部门的总资源份额减去 B B B 部门的总资源份额的差值最大可以是多少？

输入格式

第一行包含一个整数 N N N，表示分配方案的天数。

第二行包含 N N N 个整数 P 1 , P 2 , … , P N P_1, P_2, \dots , P_N P1​,P2​,…,PN​，表示 B B B 部门在第 1 1 1 天到第 N N N 天提交的需求等级。

输出格式

输出一个整数，表示 A A A 部门的总资源份额减去 B B B 部门的总资源份额的最大差值。

输入输出样例 #1
输入 #1
3
1 3 2
输出 #1
2
思路
  • A 部门可以按田忌赛马策略：用最小赢对方最大，用最大弃对方最强。
Java代码


import java.io.*;

public class Main {
    static BufferedReader br  = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
        int n = Integer.parseInt(br.readLine());
        int[] ans = new int[n];
        long count = 0;
        String[] s = br.readLine().split(" ");
        for(int i = 0;i<n;i++){
            ans[i] = Integer.parseInt(s[i]);
            if(ans[i]==n){
                count-=(i+1);
            }else{
                count+=(i+1);
            }
        }
        pw.println(count);
        pw.flush();
        
    }
}

总结

  • 大家还是真的不要觉得暴力就完了，拿不了多少分的，而且我第一题还不对了，一开始还以为填空满分呢，被自己气笑了。
  • 我是力扣300题水平，感觉没发挥好，但是走出来蜜汁自信，觉得全部暴力就好了，而且考场我也是一个十分放松的状态
  • 痛定思痛，大二我将卷土重来，定个小小目标，国二！
  • 祝大家能够取得自己心仪的成绩，加油加油！
第六届蓝桥杯JavaB组省赛真题
南 墙
07-19 1万+
解题代码部分来自网友，如果有不对的地方，欢迎各位大佬评论 题目1、三角形面积 题目描述 如图1所示。图中的所有小方格面积都是1。 那么，图中的三角形面积应该是多少呢？ 请填写三角形的面积。不要填写任何多余内容或说明性文字。 28 简单的数学平面几何问题： 大正方形面积-三个三角形面积 = 最终结果 题目2、立方变自身 题目描述 观察下面的现象,某个数字的立方，按位累加仍然等于自身。 1...
第十届蓝桥杯JavaB组省赛真题
热门推荐
南 墙
06-04 3万+
试题 A: 组队 本题总分：5 分 【问题描述】 作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。 每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少？ 这个真的没什么好说的，第一题基本上都是水题 试题 B: 不同子串 本题总分：5 分 【问题描述】 一个字符串的非空子串是指字符串中长...
Java第十五届蓝桥杯大赛软件JavaB组真题
04-18
Java第十五届蓝桥杯大赛软件JavaB组真题
蓝桥杯JAVAB组-食堂题解
2401_88116825的博客
03-18 700
Hello,小伙伴们，接上一篇文章，我做这题的思路太过复杂。参考了别人的思路，咱们直接暴力枚举就完事了，简单高效。
第十六届蓝桥杯JavaB组习题练习1
Hhy220125的博客
03-30 964
蓝桥杯赛场上，选手小王脑洞大开，跑去问裁判：“裁判，蓝桥杯要是改成‘蓝桥抓猪大赛’，得抓多少头猪才能拿国一啊？”裁判愣了愣，但为了显摆幽默，淡定答道：“好说！想拿国一，从第一届开始，每届抓的猪数得是这一届的届数加上前面所有届数的总和。比如，第一届抓 11 头，第二届抓 1+2=31+2=3 头，第三届抓 1+2+3=61+2+3=6 头 …… 今年是第十六届蓝桥杯，你自己算算吧！”
2025年第十六届蓝桥杯省赛JavaB组真题回顾
最新发布
2402_86304740的博客
04-15 6420
第16届蓝桥杯省赛JavaB组回顾
2025 年蓝桥杯 Java B 组真题解析分享
wandongle的博客
04-15 1252
这篇博客我想记录一下我对今年Java B组算法题的整体思路、解法细节、以及做题过程中遇到的一些坑和收获。希望对正在备赛或者想了解蓝桥杯题型的同学有帮助，也算是给自己的一个总结和回顾。
【Java】【第八届蓝桥杯】【试题】【无答案】
安逸风声
04-08 2594
1、 标题： 购物单     小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。     这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。     小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。     现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
2024年蓝桥杯Java B组省赛真题超详解析（全）
HYY的博客
12-16 1万+
正经详细题解（全），代码均可AC。不是标题党！讨厌TMD标题党！！如有疑惑欢迎评论区讨论，或者@博主帮你解答o(≧▽≦)o
2023年十四届蓝桥杯省赛大学B组真题（Java完整版）
2302_76207485的博客
02-01 6966
2023年十四届蓝桥杯省赛大学B组真题完整题解
2024 第十五届蓝桥杯JavaB组省赛思路分享
qwioiwp的博客
04-13 5881
本次应该是没考什么特别难的算法，除了有一两题看到就不想做的没细想，其他的基本就是基本算法（但不是偏向模板，感觉这次比较综合，都是要在模板的基础上改挺多的），希望别留下遗憾。思路：暴力两重循环就完事了，可能有几个样例过不了，需要一点优化，我这随便糊了手指针优化，也不一定对。我没学期望，用高中知识现推的，只验证了题目给的样例，但是不知道对不对。唉，可惜开学后，课太多了，进度贼慢，又不敢矿，可恶，上学真耽误学习。啊啊，读题读了40分钟，一直没懂，也是没谁了，状态是真的差。
2018第九届蓝桥杯javaB组真题
04-02
2018年第九届蓝桥杯javaB组真题。2018年第九届蓝桥杯javaB组真题。
2020年第十一届蓝桥杯大赛国赛JavaB组题目.rar
11-14
2020年第十一届蓝桥杯大赛国赛Java大学B组题目 试题 A: 美丽的2 试题 B: 扩散 试题 C: 阶乘约数 试题 D: 本质上升序列 试题 E: 玩具蛇 试题 F: 蓝肽子序列 试题 G: 皮亚诺曲线距离 试题 H: 画廊 试题 I: 补给 试题 J: 质数行者
第十一届蓝桥杯JavaB组省赛(题目及AC题解)
03-17 2891
第十一届蓝桥杯JavaB组省赛(题目及AC题解)
2024年第十四届蓝桥杯JavaB组省赛真题及解析_蓝桥杯javab组真题解析
2401_86444212的博客
09-03 1673
当我写出代码准备测试的时候，我突然惊厥，把一个数组分成两个子数组 R1，R2，如果下标为0，1的子元素符合条件，那么{0，1}就是一种情况，但{1，0}就不能算进去，很不巧我的暴力解法，将两种情况都纳入了😭 我当时就直呼热烈的马，也就是说，我还得去重！这道题我是真不擅长😢我几乎都是做数组题目，他给的这个网格题我是真没咋做过，我最开始暴力一点的想法是整一个用数组代替这个平面，符合的范围标记上，最后查看该数组内的有多少被标记了，就是所要求矩形总面积。
2021年第十二届蓝桥杯javaB组题解
weixin_52199120的博客
11-14 6782
第十二届蓝桥杯javaB组
2023年第十四届蓝桥杯JavaB组省赛真题及全部解析（上）
2301_80035594的博客
06-28 1857
2023年第十四届蓝桥杯Java B组省赛全部解析（上）。
2023年十四届蓝桥杯国赛（JavaB组）
m0_62573287的博客
06-20 7722
2023.6.16: 出成绩了，国一第15前排靠后，算是完成任务先简单写写，数据范围可能有小错，等题面出来了再更新。
2012蓝桥杯初赛试题(本科组)
java开发指南博客 【转载】
04-07 223
由于篇幅较长，解析放在下篇博文里。在此，谢谢DD提供题。 第一题： 微生物增殖 假设有两种微生物 X 和 Y X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。 一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。 现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。 如果X=10，Y=90 呢？ 本题的要求...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值