第十一届蓝桥杯模拟赛JAVA题解

欢迎指出错误,共同学习!

 

一、问题描述

一个数被称为质数(或素数)是指除开1和它本身两个约数外,没有其他的约数。
在不超过10000的数中,一共有多少个质数?

1229

二、问题描述

1200000有多少个约数(只计算正约数)。

96

三、问题描述 

将LANQIAO中的字母重新排列,可以得到不同的单词,如LANQIAO、AAILNOQ等,注意这7个字母都要被用上,单词不一定有具体的英文意义。
请问,总共能排列如多少个不同的单词。

全排列   答案:2520
public 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;
	}
}

 

你可能感兴趣的:(蓝桥杯,算法,蓝桥杯,JAVA)