说明

博主自己水平有限，而且答案也不一定对，下面代码和思路仅作分享。我只把我考场上做了的写出来了，有什么问题欢迎评论区交流。

A：逃离高塔

思路：

由于有了去年的经验，所以一上来我就是找规律，然后用 IDE 大概列了 30 多个用例，就发现了规律，最后一位的规律是：1 8 7 4 5 6 3 2 9 0，而且出现 3 是第七个

所以结果就是 2025 / 10 + 0 = 202

代码：

public class Main {
	public static void main(String[] args) {
		for(int i = 1; i <= 30; i++) {
			System.out.println(Math.pow(i, 3));
			
		}
	}
}

 C：电池分组

思路：

个人感觉要理解这一点：能否分成两组，使得这两组能量电池的能量值异或和相等。那么这两组的异或和相等的话，那这两组异或和的结果再进行异或，那不就是0吗，所以问题就转变成了：只要所有输入数据进行异或，结果为0，就是 Yes，否则就是 No

代码：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		for(int i = 0; i < n; i++) {
			int len = sc.nextInt();
			int[] arr = new int[len];
			for(int j = 0; j < len; j++) {
				arr[j] = sc.nextInt();
			}
			
			int res = arr[0];
			for(int j = 1; j < len; j++) {
				res ^= arr[j];
			}
			
			if(res == 0) {
				System.out.println("YES");
			}else {
				System.out.println("NO");
			}
		}
	}
}

D：魔法科考试

思路：

这个的话，个人感觉就是纯模拟了，时间复杂度是O(n^2)，所以对于这个，我做了一些减枝，具体是如下做的：

因为 s <= n + m 才有效，所以我首先是对数组进行了排序，然后这样的话，好做一个减枝的操作。

这里还有一个点，看题中的例子：2 + 5 = 3 + 4 = 7 <= 7，但是按照样例输出来看，这两种情况是算一种的，所以是需要一个 set 来进行去重的。

代码：

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		int m = sc.nextInt();
		
		int[] arrN = new int[n];
		int[] arrM = new int[m];
		
		for(int i = 0; i < n; i++) {
			arrN[i] = sc.nextInt();
		}
		
		for(int j = 0; j < m; j++) {
			arrM[j] = sc.nextInt();
		}
		
		Arrays.sort(arrN);
		Arrays.sort(arrM);
		int sum = n + m;
		int count = 0;
		
		Set<Integer> set = new HashSet<>();
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				int num = arrN[i] + arrM[j];
				if(num > sum) break;
				if(isNum(num) && num <= sum && !set.contains(num)) {
					count++;
				}
				set.add(num);
			}
		}
		
		System.out.println(count);
	}
	
	public static boolean isNum(int n) {
		for(int i = 2; i < n; i++) {
			if(n % i == 0) {
				return false;
			}
		}
		return true;
	}
}

G：2的幂

思路：

这里当时做的时候，真没啥好思路，而且看到是 G 了，有点儿难度很正常，所以这里选择了暴力骗分，大概就是 O(n ^ 4) 模拟一下，然后取的数值别太大，要不然容易超时

代码： 

package com.tyust;

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		int k = sc.nextInt();
		
		int[] arr = new int[n];
		
		for(int i = 0; i < n; i++) {
			arr[i] = sc.nextInt();
		}
		
		
		
		boolean flag = true;
		int res = 0;
		for(int t = 1; t < 50 && flag; t++) {
			for(int i = 1; i < 50 && flag; i++) {
				for(int j = 1; j < 50 && flag; j++) {
					for(int kT = 1; kT < 50 && flag; kT++) {
						int n1 = arr[0] + i, n2 = arr[1] + j, n3 = arr[2] + kT;
						if(n1 * n2 * n3 == Math.pow(2, k) * t) {
							res = i + j + kT;
							flag = false;
						}
						if(!flag) break;
					}
					if(!flag) break;
				}
				if(!flag) break;
			}
			if(!flag) break;
		}
		
		System.out.println(res);
	}
}