[第十六届蓝桥杯 JavaB 组] 真题 + 经验分享

A：逃离高塔(AC)

这题就是简单的签到题，按照题意枚举即可。需要注意的是不要忘记用long，用int的话会爆。

📖 代码示例：

import java.io.*;
import java.util.*;
public class Main {public static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));public static Read in = new Read();public static void main(String[] args) throws IOException{long sum = 0;for(long i = 1;i <= 2025;i++){long num = i * i * i;if(num % 10 == 3){sum++;}}System.out.println(sum);}
}
//快读模板不必在意
class Read{StringTokenizer st = new StringTokenizer("");BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String next() throws IOException{while(!st.hasMoreTokens()){st = new StringTokenizer(br.readLine());}return st.nextToken();}int nextInt() throws IOException{return Integer.parseInt(next());}long nextLong() throws IOException{return Long.parseLong(next());}double nextDouble() throws IOException{return Double.parseDouble(next());}
}

📕 答案：202

B：消失的蓝宝(AC)

这题最开始尝试用暴力枚举，但后来跑了好长时间，又扩大了好多次范围，还是没能出结果，硬想了半天，觉得应该和最小公倍数有关：

要知道，要找到一个最小数，使得同时能被 a 和 b 整除，那么这个数就是 a 和 b 的最小公倍数。

题目中要求找到一个 n，满足(n + a) % b == 0 && (n + b) % a == 0，那么只要我们找到 a 和 b 的最小公倍数 c，此时c满足 c % a == c % b == 0。

那么 因为 c % a == 0 可以知道 (c - a) % a == 0。
同理 因为 c % b == 0 可以知道 (c - b) % b == 0。

假设现在我们有一个 n 满足 (n + a) % b == 0 那么 (n + a) = (c - b)
同理 (n + b) % a == 0 那么 (n + b) = (c - a)

最终得到 n = c - a - b

📖 代码示例：

import java.io.*;
import java.util.*;
public class Main {public static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));public static Read in = new Read();public static void main(String[] args) throws IOException{long a = 20250412;long b = 20240413;System.out.println((a * b / gcd(a,b)) - a - b);}public static long gcd(long a,long b){return b == 0 ? a : gcd(b,a % b);}
}
class Read{StringTokenizer st = new StringTokenizer("");BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String next() throws IOException{while(!st.hasMoreTokens()){st = new StringTokenizer(br.readLine());}return st.nextToken();}int nextInt() throws IOException{return Integer.parseInt(next());}long nextLong() throws IOException{return Long.parseLong(next());}double nextDouble() throws IOException{return Double.parseDouble(next());}
}

📕 答案：409876661809331

C：电池分组(AC)

该题考察的是对异或操作符的理解，题中的要求是给定一个数组，让我们判断，这个数组是否能够分成两部分，使得"两部分的异或和相等"。

异或操作符：两个数字，二进制位相同为0，否则为1。

我们得清楚，不管如何划分数组，整个数组的"异或和"都是不变的，而如果数组能够分成"两个异或和相等的部分"，也就意味着，最后再将这两部分的异或和进行异或，结果必然是等于0的。(数字相等，所有二进制位相同)

那么这两部分异或和的异或，所得到的结果，代表什么呢？没错，代表整个数组的异或和。

那么也就是说：如果能找到这样的两部分，则代表整个数组的异或和一定为0。

反过来想，如果一个数组的异或和为0，是否就能代表一定存在这样的两部分呢？

是一定的。因为如果一个数组异或和为0，则代表最后的一步异或和，一定会是"两部分数组的异或和"进行异或，并且"这两部分的异或和一定相等"，否则就违背了"整个数组异或和为0"的前提了。

所以：如果整个数组异或和为0，则输出"YES"，否则，输出"NO"。

📖 代码示例：

import java.io.*;
import java.util.*;public class Main {public static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));public static Read in = new Read();public static void main(String[] args) throws IOException {int t = in.nextInt();while(t-- > 0){int n = in.nextInt();int[] arr = new int[n];for(int i = 0;i < n;i++){arr[i] = in.nextInt();}long sum = arr[0];for(int i = 1;i < n;i++){sum = arr[i] ^ sum;}System.out.println(sum == 0 ? "YES" : "NO");}}
}
class Read{StringTokenizer st = new StringTokenizer("");BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String next() throws IOException{while(!st.hasMoreTokens()){st = new StringTokenizer(br.readLine());}return st.nextToken();}int nextInt() throws IOException{return Integer.parseInt(next());}long nextLong() throws IOException{return Long.parseLong(next());}double nextDouble() throws IOException{return Double.parseDouble(next());}
}

D：魔法科考试(AC)

该题考察的是"素数筛法"，这边我采用的是最常用的"埃氏筛"，这题的数据范围是：

所以说我们只需要筛到大于40000的范围就好了，当然，即使这个范围不大，不使用优化筛法的话肯定也还是会超时的。因为使用双重for循环去检查所有魔法组合就已经有O(n^2)了~

注意：1 + 6 和 3 + 4 和 4 + 3，这种结果相同的"魔法口诀"，算是同一个，不能重复计数，所以应该去重。

📖 代码示例：

import java.io.*;
import java.util.*;public class Main {public static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));public static Read in = new Read();public static int[] zhi = new int[50100];public static boolean[] check = new boolean[50100];public static HashSet<Integer> set = new HashSet<>();public static void main(String[] args) throws IOException {shai();int a = in.nextInt();int b = in.nextInt();int[] arr1 = new int[a + 1];int[] arr2 = new int[b + 1];for(int i = 0;i < a;i++){arr1[i] = in.nextInt();}for(int i = 0;i < b;i++){arr2[i] = in.nextInt();}int max = 0;for(int i = 0;i < a;i++){for(int j = 0;j < b;j++){int num = arr1[i] + arr2[j];if(num <= a + b && zhi[num] == 1){if(!set.contains(num)){set.add(num);max++;}}}}System.out.println(max);}public static void shai(){for(int i = 2;i < 50049;i++){//未被筛出if(!check[i]){//标记为质数zhi[i] = 1;//将i的倍数都筛出for(int j = i;j < 50049;j += i){check[j] = true;}}}}
}
class Read{StringTokenizer st = new StringTokenizer("");BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String next() throws IOException{while(!st.hasMoreTokens()){st = new StringTokenizer(br.readLine());}return st.nextToken();}int nextInt() throws IOException{return Integer.parseInt(next());}long nextLong() throws IOException{return Long.parseLong(next());}double nextDouble() throws IOException{return Double.parseDouble(next());}
}

E：爆破

这题考察的应该是最小生成树...俺不会，写的dijkstra，运气好的话希望能骗个一两分吧...

F：数组翻转(AC)

数据范围：

我们先考虑暴力解法：

其实就是将所有可能的翻转都尝试一遍，这样就能找到所有的情况，并且找出最大的。

但翻转这个操作本身就是O(n)的，再加上尝试所有范围翻转，就达到了O(n^3)，这是非常可怕的

(即使如此也能暴力掉20%，也就是3分，接近一道填空题的分数了~)

但实际上，我们并不需要进行"翻转"这个操作，因为：

翻转数组的目的是：得到可通过拼接得到的最长目标值。
而我们再想一下，如何能知道"可拼接得到的最长目标值串"呢？其实，就是找到整个数组中，"等于目标值的最长子串"和"等于目标值的第二长子串"进行拼接即可。

如何证明？其实很好想，不管如何选取范围翻转，我们都没法改变范围内数组的本质顺序，也就是说，我们只能"选取部分进行拼接"，而每次拼接，肯定只能选到两个子串拼接，如果想选三个，那么势必会有两个子串中有间隔。

所以，我们只需要找到"每个值对应数组中的第一长与第二长子串"，将长度相加后，进行求分数即可，最后找到"子串拼接后分数最高的值"，输出即可。

import java.util.*;
import java.io.*;public class Main {public static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));public static Read in = new Read();public static void main(String[] args) throws IOException{int n = in.nextInt();int[] arr = new int[n + 1];HashSet<Integer> set = new HashSet<>();for(int i = 1;i <= n;i++){arr[i] = in.nextInt();set.add(arr[i]);}arr[0] = Integer.MAX_VALUE;HashMap<Integer,Integer> map1 = new HashMap<>();HashMap<Integer,int[]> map2 = new HashMap<>();int l = 1;int r = 1;while(r <= n){int len = map1.getOrDefault(arr[l],0);int newlen = 0;while(r <= n && arr[l] == arr[r]){newlen++;r++;}if(len < newlen){len = newlen;map1.put(arr[l],len);map2.put(arr[l],new int[]{l,r});}l = r;}HashMap<Integer,Integer> map3 = new HashMap<>();l = r = 1;//再次进行查找数组中的[第二长子串],跳过第一长子串即可while(r <= n){//为val = arr[l]的最长字串if(map2.get(arr[l])[0] == l){l = map2.get(arr[l])[1];r = l;continue;}int len = map3.getOrDefault(arr[l],0);int newlen = 0;while(r <= n && arr[l] == arr[r]){newlen++;r++;}if(len < newlen){len = newlen;map3.put(arr[l],len);}l = r;}long max = 0;for(int a:set){//有可能不存在第二长子串int len = map1.get(a) + map3.getOrDefault(a,0);long num = len * 1l * a;max = Math.max(max,num);}System.out.println(max);}
}
class Read{StringTokenizer st = new StringTokenizer("");BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String next() throws IOException{while(!st.hasMoreTokens()) {st = new StringTokenizer(br.readLine());}return st.nextToken();}String nextLine() throws IOException{return br.readLine();}int nextInt() throws IOException{return Integer.parseInt(next());}long nextLong() throws IOException{return Long.parseLong(next());}double nextDouble() throws IOException{return Double.parseDouble(next());}
}

G：2的幂

这题不会...but！

所以我写的时候，先判断原数组是不是已经满足条件了，如果满足直接输出0，不满足直接输出-1...不知道能不能骗到分。

H：研发资源分配

范围：

不会...只会用全排列暴力骗分。

---

总的来说，感觉今年蓝桥杯的数学和贪心含量太高了...考前学了一堆算法，dijkstra，floyd，并查集，最近公共祖先...一个都没出呀，这就算了...二分，bfs，dfs都没出。有种学了半年砌砖，最后考我电焊的感觉.难受