第十一届蓝桥杯模拟赛JAVA题解
欢迎指出错误，共同学习！
一、问题描述
一个数被称为质数（或素数）是指除开1和它本身两个约数外，没有其他的约数。
在不超过10000的数中，一共有多少个质数?
1229
二、问题描述
1200000有多少个约数（只计算正约数）。
96三、问题描述
将LANQIAO中的字母重新排列，可以得到不同的单词，如LANQIAO、AAILNOQ等，注意这7个字母都要被用上，单词不一定有具体的英文意义。
请问，总共能排列如多少个不同的单词。
全排列 答案：2520public class Main{
static Setset = new HashSet<>();
static StringBuilder sb = new StringBuilder("LANQIAO");
public static void main(String []args){
dfs(0);
System.out.println(set.size());
}
static void dfs(int idx) {
if(idx == sb.length()) {
set.add(sb.toString());
return;
}
for(int i = idx;i < sb.length();i ++) {
char t = sb.charAt(i);
sb.setCharAt(i, sb.charAt(idx));
sb.setCharAt(idx, t);
dfs(idx+1);
t = sb.charAt(i);
sb.setCharAt(i, sb.charAt(idx));
sb.setCharAt(idx, t);
}
}
} 四、问题描述
一个包含有2019个结点的二叉树，最少有多少层？
注意当一棵二叉树只有一个结点时为一层。
求最少，则构建一棵完全二叉树，第i层最多有2^(i-1)个节点，算一下就知道了
答案： 10五、问题描述
给定一个单词，请使用凯撒密码将这个单词加密。
凯撒密码是一种替换加密的技术，单词中的所有字母都在字母表上向后偏移3位后被替换成密文。即a变为d，b变为e，...，w变为z，x变为a，y变为b，z变为c。
例如，lanqiao会变成odqtldr。
输入格式：
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式：
输出一行，表示加密后的密文。
样例输入：
lanqiao
样例输出：
odqtldr
评测用例规模与约定：
对于所有评测用例，单词中的字母个数不超过100。
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
for(int i = 0;i < s.length();i ++) {
char c = s.charAt(i);
if(c <= 'w') {
System.out.print((char)(c+3));
}else if(c == 'x'){
System.out.print('a');
}else if(c == 'y'){
System.out.print('b');
}else if(c == 'z'){
System.out.print('c');
}
}
}
}六、问题描述
小明非常不喜欢数字 2，包括那些数位上包含数字 2 的数。如果一个数的数位不包含数字 2，小明将它称为洁净数。
请问在整数 1 至 n 中，洁净数有多少个？
输入格式：
输入的第一行包含一个整数 n。
输出格式：
输出一行包含一个整数，表示答案。
样例输入：
30
样例输出：
18
评测用例规模与约定：
对于 40% 的评测用例，1 <= n <= 10000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int ans = 0;
int n = sc.nextInt();
for(int i = 1;i <= n;i ++) {
if(check(i)) {
ans ++;
}
}
System.out.println(ans);
}
static boolean check(int num) {
while(num != 0) {
int t = num % 10;
if(t == 2) {
return false;
}
num /= 10;
}
return true;
}
}七、问题描述
输入一个单词，请输出这个单词中第一个出现的元音字母。
元音字母包括 a, e, i, o, u，共五个。
输入格式：
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式：
输出一行包含一个字母，为单词中第一个出现的元素字母。若单词中不存在元音字母，输出字母n。
样例输入：
hello
样例输出：
e
样例输入：
fly
样例输出：
n
评测用例规模与约定：
对于所有评测用例，单词中的字母个数不超过100。
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
for(int i = 0;i < s.length();i ++) {
char c = s.charAt(i);
if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
System.out.println(c);
return;
}
}
System.out.println("n");
}
}八、问题描述
小明开了一家花店，这天，有个客户定了非常多的花，按客户的需要，这些花要排成 n 行 m 列。
小明要将这些花运送到客户那，然而由于花太多，需要分两辆车才能装下。
小明怕自己弄错花的顺序，因此在分车的时候，他准备将前面一些列（注意不是行）的花放在第一辆车上，将其实的花放在第二辆车上。
已知每盆花的重量，要使第一辆车和第二辆车尽可能总重量一致，请帮助小明分装这些花，请告诉小明两辆车的重量最小差多少。
输入格式：
输入的第一行包含两个整数 n, m，分别表示行数和列数。
接下来 n 行，每行 m 个正整数，分别表示每盆花的重量。
输出格式：
输出一个整数，表示总重量最接近时两车的重量之差（的绝对值）。
样例输入：
3 4
1 2 3 9
5 6 7 8
2 3 4 9
样例输出：
7
样例说明：
将前 3 列放一辆车，后 1 列放一辆车，第一辆比第二辆重 7 。
评测用例规模与约定：
对于 30% 的评测用例，2 <= n, m <= 20。
对于 70% 的评测用例，2 <= n, m <= 100。
对于所有评测用例，2 <= n, m <= 1000，每盆花的重量不超过 1000。
import java.util.*;
public class Main{
static int[]arr = new int [1005];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int sum = 0;
for(int i = 1;i <= n;i ++) {
for(int j = 1;j <= m;j ++) {
int num = sc.nextInt();
arr[j] += num;
sum += num;
}
}
int L = 0,ans = Integer.MAX_VALUE;
for(int i = 1;i < m;i ++) {
L += arr[i];
int R = sum - L;
ans = Math.min(ans, Math.abs(R-L));
}
System.out.println(ans);
}
}九、问题描述
一个平面向量表示从一个坐标点到另一个坐标点的变化量，一般用两个数 (x, y) 来表示。
两个向量相加是指分别将对应的两个数相加，例如 (x_1, y_1) 与 (x_2, y_2) 相加后得 (x_1+x_2, y_1+y_2)。
如果两个向量相加后，得到的向量两个值相等，我们称这两个向量为和谐向量对。例如 (3, 5) 和 (4, 2) 是和谐向量对。
给定 n 个向量，问能找到多少个和谐向量对？
输入格式：
输入的第一行包含一个整数 n，表示向量的个数。
接下来 n 行，每行两个整数 x_i, y_i，表示一个向量。
输出格式：
输出一行，包含一个整数，表示有多少个和谐向量对。
请注意，自己和自己不能成为一个和谐向量对。
样例输入：
5
9 10
1 3
5 5
5 4
8 6
样例输出：
2
样例输入：
4
1 1
2 2
1 1
2 2
样例输出：
6
样例说明：
每两个向量组成一个和谐向量对。
评测用例规模与约定：
对于 70% 的评测用例，1 <= n <= 1000；
对于所有评测用例，1 <= n <= 100000，-1000000 <= x_i, y_i <= 1000000。
请注意答案可能很大，可能需要使用 long long 来保存。
注意：该解法只能拿部分分数！import java.util.*;
public class Main{
static int[][]arr = new int [100005][2];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 1;i <= n;i ++) {
arr[i][0] = sc.nextInt();
arr[i][1] = sc.nextInt();
}
long ans = 0L;
for(int i = 1;i <= n;i ++) {
for(int j = i+1;j <= n;j ++) {
if(arr[i][0]+arr[j][0] == arr[i][1]+arr[j][1]) {
ans ++;
}
}
}
System.out.println(ans);
}
}十、问题描述
给出三个水杯，大小不一，并且只有最大的水杯的水是装满的，其余两个为空杯子。
三个水杯都没有标刻度线，在水杯之间可以相互倒水。当从一个杯子向另一个杯子倒水时，只能将一个杯子的水倒空或者将另一个杯子的水倒满。不允许倒到三个杯子以外的地方。
给定一个目标状态，请写出一个程序，使其输出使初始状态到达目标状态的最少次数。
输入格式：
输入的第一行包含一个整数 n，表示总共有 n 组测试数据。
接下来每组测试数据包含两行，第一行包含三个整数 V_1，V_2，V_3，分别表示三个水杯的体积。
每组数据的第二行包含三个整数E_1，E_2，E_3（体积小于等于相应水杯体积）表示最终状态。
输出格式：
输出 n 行，每行对应一组数据的结果。
如果可以达到最终状态，输出最少的倒水次数，如果不能达到目标准备，输出-1。
样例输入：
2
6 3 1
4 1 1
9 3 2
7 1 1
样例输出：
3
-1
评测用例规模与约定：
对于所有评测用例，0
经典BFS，代码量大，但其实大部分是重复代码import java.util.*;
public class Main{
static class node{
int a,b,c,step;
public node(int a,int b,int c,int step) {
this.a = a;
this.b = b;
this.c = c;
this.step = step;
}
}
static boolean [][][]vis = new boolean[105][105][105];
static LinkedListlist = new LinkedList<>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0;i < n;i ++) {
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int x = sc.nextInt();
int y = sc.nextInt();
int z = sc.nextInt();
bfs(a,b,c,x,y,z);
}
}
static void bfs(int a,int b,int c,int x,int y,int z) {
for(int i = 0;i <= 100;i ++) {
for(int j = 0;j <= 100;j ++) {
for(int k = 0;k <= 100;k ++) {
vis[i][j][k] = false;
}
}
}
while(!list.isEmpty()) {
list.pollFirst();
}
list.add(new node(a,0,0,0));
vis[a][0][0] = true;
while(!list.isEmpty()) {
node cur = list.pollFirst();
if(cur.a == x && cur.b == y && cur.c == z) {
System.out.println(cur.step);
return;
}
//a倒向b,c
if(cur.a > 0) {
if(cur.b < b) {
if(cur.a >= b - cur.b && !vis[cur.a-(b-cur.b)][b][cur.c]) {
list.add(new node(cur.a-(b-cur.b),b,cur.c,cur.step+1));
vis[cur.a-(b-cur.b)][b][cur.c] = true;
}else {
if(!vis[0][cur.b + cur.a][cur.c]) {
list.add(new node(0,cur.b + cur.a,cur.c,cur.step+1));
vis[0][cur.b + cur.a][cur.c] = true;
}
}
}
if(cur.c < c) {
if(cur.a >= c - cur.c && !vis[cur.a-(c-cur.c)][cur.b][c]) {
list.add(new node(cur.a-(c-cur.c),cur.b,c,cur.step+1));
vis[cur.a-(c-cur.c)][cur.b][c] = true;
}else {
if(!vis[0][cur.b][cur.c+cur.a]) {
list.add(new node(0,cur.b,cur.c+cur.a,cur.step+1));
vis[0][cur.b][cur.c+cur.a] = true;
}
}
}
}
//b倒向a,c
if(cur.b > 0) {
if(cur.a < a) {
if(cur.b >= a - cur.a && !vis[a][cur.b - (a - cur.a)][cur.c]) {
list.add(new node(a,cur.b - (a - cur.a),cur.c,cur.step+1));
vis[a][cur.b - (a - cur.a)][cur.c] = true;
}else {
if(!vis[cur.a+cur.b][0][cur.c]) {
list.add(new node(cur.a+cur.b,0,cur.c,cur.step+1));
vis[cur.a+cur.b][0][cur.c] = true;
}
}
}
if(cur.c < c) {
if(cur.b >= c - cur.c && !vis[cur.a][cur.b - (c - cur.c)][c]) {
list.add(new node(cur.a,cur.b - (c - cur.c),c,cur.step+1));
vis[cur.a][cur.b - (c - cur.c)][c] = true;
}else {
if(!vis[cur.a][0][cur.c+cur.b]) {
list.add(new node(cur.a,0,cur.c+cur.b,cur.step+1));
vis[cur.a][0][cur.c+cur.b] = true;
}
}
}
}
//c倒向a,b
if(cur.c > 0) {
if(cur.a < a) {
if(cur.c >= a - cur.a && !vis[a][cur.b][cur.c - (a - cur.a)]) {
list.add(new node(a,cur.b,cur.c - (a - cur.a),cur.step+1));
vis[a][cur.b][cur.c - (a - cur.a)] = true;
}else {
if(!vis[cur.a+cur.c][cur.b][0]) {
list.add(new node(cur.a+cur.c,cur.b,0,cur.step+1));
}
}
}
if(cur.b < b) {
if(cur.c >= b - cur.b && !vis[cur.a][b][cur.c - (b - cur.b)]) {
list.add(new node(cur.a,b,cur.c - (b - cur.b),cur.step+1));
vis[cur.a][b][cur.c - (b - cur.b)] = true;
}else {
if(!vis[cur.a][cur.b+cur.c][0]) {
list.add(new node(cur.a,cur.b+cur.c,0,cur.step+1));
vis[cur.a][cur.b+cur.c][0] = true;
}
}
}
}
}
System.out.println("-1");
return;
}
}