蓝桥杯第十四届模拟赛第二期试题【Java解析】
填空1
问题描述：
请找到一个大于 2022 的最小数，这个数转换成二进制之后，最低的 6 个二进制为全为 0 。
请将这个数的十进制形式作为答案提交。
答案提交：
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：2048
个人解析：
众所周知 2^10 = 1024（不会有人不知道吧），所以 2^11 = 2048，因此低位 11 位的最大值为2^11– 2^6 = 2048 - 64 = 1984 < 2022，因此进位，第 12 位为 1（2^12 = 2048），其余低位全为 0。
辅助理解：
111（2） = 1 * 2^0 + 1 * 2^1 + 1 * 2^2 = 1 + 2 + 4 = 7，注意，这个式子又等于1000（2） = 1 * 2^3 – 1 = 8 – 1 = 7。不多说，这个要是不明白要去学习一下二进制转换了。
代码：
public class Main {
public static void main(String[] args) {
int i = 0b11111_000000;
int j = 0b100000_000000;
System.out.println("i=" + i + "\nj=" + j);
/*
输出：i=1984
j=2048
*/
}
}
填空2
问题描述：
我们计从 1949 年 10 月 1 日至 1949 年 10 月 2 日为经过了 1 天。
请问从 1949 年 10 月 1 日至 2022 年 1 月 1 日经过了多少天？
答案提交：
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：26390
个人解析：
思路是利用 Calendar 日历获取所求这两天分别距离 1970 年 1 月 1 日 0 时 0 分 0 秒的毫秒数，它们两的差值再除以 24 * 60 * 60 * 1000，即为所求结果。当然也可以用日期 Date 去获取毫秒数计算，但那些方法基本都过时了，而且还要对 “年” 和 “月” 进行特殊处理。
代码：
import java.util.Calendar;
public class Main {
public static void main(String[] args) {
Calendar cal1 = Calendar.getInstance();
cal1.clear(); // 1970 年 1 月 1 日 0 时 0 分 0 秒
cal1.set(1949, 9, 1); // month范围是 0 - 11
Calendar cal2 = Calendar.getInstance();
cal2.clear();
cal2.set(2022, 0, 1);
// 注意类型转换
int day = (int)((cal2.getTimeInMillis() - cal1.getTimeInMillis()) / (24 * 60 * 60 * 1000.0));
System.out.println(day);
/*
输出：26390
*/
}
}
填空3
问题描述：
8518 是一个非常特殊的数，如果把这个数看成 16 进制数，它的值为 (8518)16 = 8 * 16 * 16 * 16 + 5 * 16 * 16 + 1 * 16 + 8 = 34072，而 34072 正好是 8518 的整数倍。
9558 也是这样一个数，当看成 16 进制时是 38232。
其实长度为 1 的数 0 到 9 都满足看成 16 进制后是自己的整数倍（1倍）。
请问，除开长度为 1 的数，最小的满足这样条件的数是多少？
答案提交：
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：1038
个人解析：
取十进制的每一位，然后按十六进制的求法，最低位乘1，高位乘16的次幂，然后累加，考虑用for循环和Math.pow混搭这个比较巧妙。
代码：
public class Main {
public static void main(String[] args) {
int dec = 10, decToHex = 0;
while(true) {
char[] chars = (dec + "").toCharArray(); // int -> String -> char[]
for (int j = 0; j < chars.length; j++) {
decToHex += (int) ((chars[j] - '0') * Math.pow(16, chars.length - j - 1));
}
if(decToHex % dec == 0){ // 整除则退出
System.out.println(dec);
return;
}
dec++;
decToHex = 0;
}
}
}
填空4
问题描述：
小蓝有一个 30 行 60 列的数字矩阵，矩阵中的每个数都是 0 到 9 之间的数字。
现在小蓝想从这个矩阵的第一行第一列画一条折线到第 30 行 60 列，线只能沿水平向右走或竖直向下走，只能在有数字的地方拐弯。小蓝想知道，这样一条线经过的数字的和最大是多少。
174094882455171152761423221685761892795431233411387427793198
650286024865090061389344606618496378829135984076361542097372
601657541200146071777733599818266038012509478351201640618984
143988087783837107349651099683484992553337438088068198972282
890781586124258626539246182119762952003918195325258677229419
698255491250839396799769357665825441616335532825361862146291
503649293440596342887581257444442930778730382520372975343211
325351222640703400531067500454956482168314849207060705673849
265774579830223671554026061117300483012903885770893074783710
083450145620356667677191627276513995926532444279237315785832
411595106453089134746365281031552217482363035280722591085079
053410485925413958279617719034175332412908745680774313630190
429314820559328748143552689295945058801322270313370955837837
939182801848609300876356583948397645861551964542532682663945
625356614462682551015176002433628234343684739800880514363921
982340231989891351425389287014819359798014755509282450440511
590838726938103384801541373585690893606978941566666714061214
952341523168827712604946036245881214982452998386986623826275
782780208928205527678781609589000725521486468983551558405472
149903035076783644195574734088152324666290493119955560594634
905391288186024902215444250421277955403412298227858394469856
607272647132163832860126054679347881638761723785858733108109
249157334220127702410373959720286708183036202841837581704881
367895556630088230650972282944827258473951902831431040790814
079538232104075905120989173307660289899942087873076421916033
622143260549608274076012938515668898707915863945382394851328
164677964192631597026176253407553188801750590935427267220117
591817866992665840378311257621611574856498432538327068011953
631534031790352912617015229051836886166704989498756486878095
690013558017746707412183571476823027885971347137127534455141
答案提交：
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：592
个人解析：
这题和经典的 “礼物的最大价值” 思路一样，这个地址的知识理解了话这题也就会了，点这里。
代码：
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int[][] arr = new int[30][];
try {
readFileToIntArray("src/com/lqb/in.txt", arr);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
System.out.println(valueMax(arr));
}
/**
* 读取文件内容存入整型数组
* @param fileName
* @param arr
* @throws FileNotFoundException
*/
public static void readFileToIntArray(String fileName, int[][] arr) throws FileNotFoundException {
Scanner scan = new Scanner(new FileReader(fileName));
while (scan.hasNext()) {
for (int i = 0; i < arr.length; i++) {
// 利用 split+正则表达式 将字符串转换成 String[]，在转为int[]
arr[i] = Arrays.stream(scan.next().split("[^0-9]*")).mapToInt(Integer::parseInt).toArray();
}
}
}
/**
* 动态规划求矩阵 grid 的最大值
* @param grid
* @return 最大值
*/
public static int valueMax(int[][] grid) {
int row = grid.length;
int column = grid[0].length;
int[][] dp = new int[row + 1][column + 1];
for (int i = 1; i <= row; i++) {
for (int j = 1; j <= column; j++) {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]) + grid[i - 1][j - 1];
}
}
return dp[row][column];
}
}
填空5
问题描述：
将 2022 拆分成不同的质数的和，请问最多拆分成几个？
答案提交：
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：33
个人解析： 01背包问题，b站的视频解析。
代码：
public class Main {
public static void main(String[] args) {
int[] primes = new int[2023], f = new int[2023];
int cnt = 0;
for (int i = 2; i < 2022; i++)
if (isPrime(i)) primes[++cnt] = i;
for (int i = 1; i <= cnt; i++)
for (int j = 2022; j >= 2; j--)
if (primes[i] <= j)
f[j] = Math.max(f[j], f[j - primes[i]] + 1);
System.out.println(f[2022]);
}
// 开根号求质素法
public static boolean isPrime(int x) {
for (int i = 2; i <= x / i; i++) // i <= x / i 就是 i<= sqrt(x)
if (x % i == 0) return false;
return true;
}
}
编程6
问题描述：
小蓝正在拷贝一份文件，他现在已经拷贝了 t 秒时间，已经拷贝了 c 字节，文件总共有 s 字节，如果拷贝是匀速进行的，请问小蓝大概还需要拷贝多少秒？
输入格式：
输入一行包含三个整数 t, c, s，相邻两个整数之间用一个空格分隔。
输出格式：
输出一个整数，表示答案。数据保证答案正好是整数。
样例输入
3 10 20
样例输出
3
样例输入
30 14 21
样例输出
15
评测用例规模与约定
对于 50% 的评测用例，1 <= t, c, s <= 10000。
对于所有评测用例，1 <= t, c, s <= 1000000000。
个人解析：
注意测试用例的规模，Java中int的最大值是Integer.MAX_VALUE 为2147483647（大于21亿， 所有整型的范围是最基本的需要记忆的），因此用int数据类型接收t, c, s是可以的，但是计算所求的结果必须转成long类型，你可以测试一下输入数据是1000000000 1 1000000000。
代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int t = scan.nextInt();
int c = scan.nextInt();
int s = scan.nextInt();
long needTime = (long)(1.0 * t / c * (s - c));
System.out.println(needTime);
scan.close();
}
}
编程7
问题描述：
小蓝有 n 个单词，但是单词中有一些是重复的，请帮小蓝去除重复的单词。
输入格式：
输入第一行包含一个正整数 n ，表示小蓝的单词数量。
接下来 n 行，每行包含一个由小写字母组成的单词。
输出格式：
请输出去除重复后的那些单词。如果一个单词出现了多遍，请保留第一次出现的单词，去除之后出现的单词，按输入的顺序输出。
样例输入
5
lanqiao
hi
hello
hello
lanqiao
样例输出
lanqiao
hi
hello
评测用例规模与约定
对于所有评测用例，1 <= n <= 100，每个单词的长度不超过 100。
个人解析：
既要保持集合中的元素不重复又要使输入的顺序和输出的顺序一致，那想到了LinkedHashSet，它是Set的分支（存储无序，不可重复的数据集合），又是HashSet的子类，它同时使用双向链表（两个引用）维护元素的次序，这使得元素看起来是以插入顺序保存的（这里要注意理解存储有序的概念和输入输出有序是两个意思）。
下述代码遍历使用foreach + 拉姆达表达式遍历，也可使用较为熟悉的迭代器进行遍历。
如果你实在不理解的话下面还有一种形式是使用List集合，不多叙述。
代码：
方式1：
import java.util.LinkedHashSet;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
LinkedHashSet<String> linkdHashSet = new LinkedHashSet<>();
int n = scan.nextInt();
scan.nextLine(); // 吸收 nextInt留下的回车
for (int i = 0; i < n; i++) {
linkdHashSet.add(scan.nextLine());
}
linkdHashSet.forEach(str -> System.out.println(str)); // foreach + 拉姆达表达式遍历
scan.close();
}
}
方式2：
import java.util.ArrayList;
import java.util.Scanner;
public class Main2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
for (int i = 0; i < n; i++) {
String str = scan.next();
if (!list.contains(str)) {
list.add(str);
}
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
编程8
问题描述：
一个字符串如果从左向右读和从右向左读相同，则称为一个回文串，例如 lanqiaoaiqnal 是一个回文串。
小蓝有一个字符串，请将这个字符串右边加上一些字符，使其成为一个回文串。
如果有多种方案，请输出最短的回文串。
输入格式：
输入一行包含一个字符串，由小写英文字母组成。
输出格式：
输出一行包含答案。
样例输入
lanqiao
样例输出
lanqiaoaiqnal
样例输入
banana
样例输出
bananab
样例输入
noon
样例输出
noon
评测用例规模与约定
对于所有评测用例，1 <= 字符串长度 <= 100。
个人理解：
思路是取子字符串（第一次取到子串为空），然后将子字符串翻转拼接到原的字符串后面，得到 possibleStr （可能是回文数的字符串），possibleStr 再翻转得到 rePossibleStr，然后在进行 if 条件判断。
注意这里比较字符串需要转成 String 类型，因为 StringBuffer、StringBuilder都没有重写 equals 方法。
代码：
import java.util.Scanner;
public class Main2 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String str = scan.next();
for (int i = 0; i <= str.length(); i++) {
String subStr = new StringBuilder(str).substring(0, i); // 取子串
StringBuilder reSubStr = new StringBuilder(subStr).reverse(); // 将字串翻转
String possibleStr = new StringBuilder(str).append(reSubStr).toString(); // 拼接 -> 可能是回文数
String rePossibleStr = new StringBuilder(possibleStr).reverse().toString(); // 翻转在判断
if (possibleStr.equals(rePossibleStr)){
System.out.println(possibleStr);
break;
}
}
scan.close();
}
}
编程9
问题描述：
给定一个字母矩阵。一个 X 图形由中心点和由中心点向四个45度斜线方向引出的直线段组成，四条线段的长度相同，而且四条线段上的字母和中心点的字母相同。
一个 X图形可以使用三个整数 r, c, L 来描述，其中 r, c 表示中心点位于第 r 行第 c 列，正整数 L 表示引出的直线段的长度。 对于 1 到 L 之间的每个整数 i，X图形满足：第 r-i 行第 c-i 列与第 r 行第 c 列相同，第 r-i 行第 c+i 列与第 r 行第 c 列相同，第 r+i 行第 c-i 列与第 r 行第 c 列相同，第 r+i 行第 c+i 列与第 r 行第 c 列相同。
例如，对于下面的字母矩阵中，所有的字母 L 组成一个 X图形，其中中间的 5 个 L 也组成一个 X图形。所有字母 Q 组成了一个 X图形。
LAAALA
ALQLQA
AALQAA
ALQLQA
LAAALA
给定一个字母矩阵，请求其中有多少个 X图形。
输入格式：
输入第一行包含两个整数 n, m，分别表示字母矩阵的行数和列数。
接下来 n 行，每行 m 个大写字母，为给定的矩阵。
输出格式：
输出一行，包含一个整数，表示答案。
样例输入
5 6
LAAALA
ALQLQA
AALQAA
ALQLQA
LAAALA
样例输出
3
评测用例规模与约定
对于 50% 的评测用例，1 <= n, m <= 10。
对于所有评测用例，1 <= n, m <= 100。
个人解析：
由题可知arr[r-i][c-i]、arr[r-i][c+i]、arr [r+i][c-i]、arr[r+i][c+i]、arr[r][c] 五个元素相同，i 最小的值是1，最大的值取决于数组的规模，所以遍历时不需要遍历外围一圈，i的最大值我们不知道但是对于i的限制就是 r-i 和 c-i 不能小于0，r+i 和 c+i 需要分别小于数组的行和列。
下述代码中的数组下标可以定义变量，为了和题目一致且方便阅读我不改动。
代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
scan.nextLine();
String[][] strArr = new String[n][];
for (int i = 0; i < n; i++) {
strArr[i] = scan.nextLine().split("[^A-Z]*");
}
int i = 1, total = 0;
for (int r = 1; r < (n - 1); r++) {
for (int c = 1; c < (m - 1); c++) {
while ((r - i) >= 0 && (c - i) >= 0 && (r + i) < n && (c + i) < m &&
strArr[r - i][c - i].equals(strArr[r - i][c + i]) &&
strArr[r - i][c - i].equals(strArr[r + i][c - i]) &&
strArr[r + i][c - i].equals(strArr[r + i][c + i]) &&
strArr[r - i][c - i].equals(strArr[r][c])) {
total++;
i++;
}
i = 1;
}
}
System.out.println(total);
scan.close();
}
}
编程10
问题描述：
小蓝有一个序列 a[1], a[2], …, a[n]，每次可以交换相邻的两个元素，代价为两个元素中较大的那个。
请问，要通过交换将序列变为从小到大递增的序列，总代价最少为多少？
输入格式：
输入一行包含一个整数 n ，表示序列长度。
第二行包含 n 个整数，表示给定的序列。
输出格式：
输出一行包含一个整数，表示最少代价的值。
样例输入
4
1 5 2 1
样例输出
12
评测用例规模与约定
对于 30% 的评测用例，1 <= n <= 1000, 1 <= a[i] <= 1000。
对于 60% 的评测用例，1 <= n <= 50000, 1 <= a[i] <= 50000。
对于所有评测用例，1 <= n <= 1000000, 1 <= a[i] <= 1000000。
个人理解：
考虑到测试用例数据非常大，因此使数组是不太现实的，所以我考虑使用集合。
题目要求递增序列，所以每次找当前集合最大值，最大值元素的下标（lastIndexOf，可能多个最大值，需要最右侧那个）和集合size的差值乘以最大值即为移动代价，每次计算完都要删掉最大值（可以理解为最大值已经放到最右端），重复此操作。
ArrayList是和数组很类似的，LinkedList和ArrayList方法使用上也基本相同，但是在删除集合中间元素这点使用链表（LinkedList）相对来说更好。
这个代码其实还可以改进，集合的元素为 0 才结束，显然这个不合适，可改进为集合递增有序则结束。
还有一个思路是归并排序…
代码：
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
List<Integer> integerList = new LinkedList<>();
for (int i = 0; i < n; i++) {
integerList.add(scan.nextInt());
}
int total = 0;
while(integerList.size() != 0) {
Integer max = Collections.max(integerList);
int lastIndexOfMax = integerList.lastIndexOf(max);
total += max * (integerList.size() - lastIndexOfMax - 1);
integerList.remove(lastIndexOfMax);
}
System.out.println(total);
scan.close();
}
}