2014第五届蓝桥杯JavaB组省赛真题题解

旧城等待， 2023-07-10 12:57 136阅读 0赞

# 第一题：武功秘籍 (填空2分) #

### Problem Description ###

小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。

小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？

这是个整数，请通过浏览器提交该数字，不要填写任何多余的内容。

### 答案 ###

7（没错，就是你想的辣么蓝~）

# 第二题：切面条 (填空5分) #

### Problem Description ###

一根高筋拉面，中间切一刀，可以得到2根面条。

如果先对折1次，中间切一刀，可以得到3根面条。

如果连续对折2次，中间切一刀，可以得到5根面条。

那么，连续对折10次，中间切一刀，会得到多少面条呢？

答案是个整数，请通过浏览器提交答案。不要填写任何多余的内容。

### 解题思路 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTgxNzcy_size_16_color_FFFFFF_t_70][]

观察规律可以发现每次的弯都比前面的多两倍加1。

### 答案 ###

1025

# 第三题：猜字母 (填空6分) #

### Problem Description ###

把abcd...s共19个字母组成的序列重复拼接106次，得到长度为2014的串。

接下来删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。

得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。

答案是一个小写字母，请通过浏览器提交答案。不要填写任何多余的内容。

### 解题代码 ###

public class Main {
    
    //	static int[] a = {1,2,3,4,5,6,7,8,9};
    //	static int n,ans = 0;
    
    	public static void main(String[] args) {
    		char[] a = new char[2015];
    		int len = 0;
    		//先将长度为2014的字符串模拟出来
    		for (int i = 0; i < 106; i++) {
    			a[len] = 'a';
    			len++;
    			for (int j = 1; j < 19; j++) {
    				a[len] = (char) (a[len-1]+1);
    				len++;
    			}
    		}
    //		System.out.println(len);
    		//然后逐次删除奇数位的字母，直到只剩一个字母
    		while (len > 1) {
    			int k = 0;
    			for (int i = 0; i < len; i++) {
    				if(i%2 != 0) {
    					a[k++] = a[i];
    				}
    			}
    			len = k;
    		}
    		System.out.println(a[0]);
    		
    		
    	}
    	
    }

### 答案 ###

# 第四题：大衍数列 (代码4分) #

### Problem Description ###

中国古代文献中，曾记载过“大衍数列”, 主要用于解释中国传统文化中的太极衍生原理。

它的前几项是：0、2、4、8、12、18、24、32、40、50 ...

其规律是：对偶数项，是序号平方再除2，奇数项，是序号平方减1再除2。

以下的代码打印出了大衍数列的前 100 项。

for(int i=1; i<100; i++)  
\{  
if(\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_) //填空  
System.out.println(i\*i/2);  
else  
System.out.println((i\*i-1)/2);  
\}

请填写划线部分缺失的代码。通过浏览器提交答案。

注意：不要填写题面已有的内容，也不要填写任何说明、解释文字。

### 答案 ###

i%2==0

# 第五题：圆周率 (代码9分) #

### Problem Description ###

数学发展历史上，圆周率的计算曾有许多有趣甚至是传奇的故事。其中许多方法都涉及无穷级数。

图1.png中所示，就是一种用连分数的形式表示的圆周率求法。

下面的程序实现了该求解方法。实际上数列的收敛对x的初始值 并不敏感。

结果打印出圆周率近似值（保留小数点后4位，并不一定与圆周率真值吻合）。

double x = 111;  
for(int n = 10000; n>=0; n--)\{  
int i = 2 \* n + 1;  
x = 2 + (i\*i / x);  
\}  
System.out.println(String.format("%.4f", \_\_\_\_\_\_\_\_\_\_\_\_\_\_));

### 解题思路 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTgxNzcy_size_16_color_FFFFFF_t_70 1][]

这道题还是挺坑的，头脑如第一题的我答案写的x（题上居然还故意说“并不一定与圆周率真值吻合”，我信了~），果然 是错的，如上图所示，一个关于计算π的小数部分的有趣图，for循环之后x是等号右边的结果还多了1，因此π等于4/（x-1）。

### 答案 ###

4/(x-1)

# 第六题：奇怪的分式 (填空11分) #

### Problem Description ###

上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：

1/4 乘以 8/5

小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png）

![20190227152058570.PNG][]

老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！

对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？

请写出所有不同算式的个数（包括题中举例的）。

显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。

但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!

注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。

### 解题思路 ###

模拟出所有可能，然后判断有多少符合条件。

### 解题代码 ###

public class Main {
    
    //	static int[] a = {1,2,3,4,5,6,7,8,9};
    //	static int n,ans = 0;
    
    	public static void main(String[] args) {
    		int ans = 0;
    		//模拟所有可能
    		for (int i = 1; i < 10; i++) {
    			for (int j = 1; j < 10; j++) {
    				if (i != j) {
    					for (int j2 = 1; j2 < 10; j2++) {
    						for (int k = 1; k < 10; k++) {
    							if (j2 != k) {
    								int x1 = j*10+k;//拼接分母
    								int y1 = i*10+j2;//拼接分子
    								int x2 = j*k;//分母相乘
    								int y2 = i*j2;//分子相乘
    								int z1 = gcd(x1,y1);
    								int z2 = gcd(x2,y2);
    								if (x1/z1 == x2/z2 && y1/z1 == y2/z2) {
    									ans++;
    								}
    							}
    						}
    					}
    				}
    			}
    		}
    		System.out.println(ans);
    		
    		
    	}
    	//求最大公因数
    	private static int gcd(int x1, int y1) {
    		int m = Math.max(x1, y1);
    		int n = Math.min(x1, y1);
    		int t = n;
    		while (m % n != 0) {
    			t = m%n;
    			m = n;
    			n = t;
    		}
    		return t;
    	}
    	
    }

### 答案 ###

# 第七题：扑克序列 (填空15分) #

### Problem Description ###

A A 2 2 3 3 4 4， 一共4对扑克牌。请你把它们排成一行。  
要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。

请填写出所有符合要求的排列中，字典序最小的那个。

例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。  
请通过浏览器提交答案。“A”一定不要用小写字母a，也不要用“1”代替。字符间一定不要留空格。

### 解题思路 ###

其实这道题不写代码也能整出来不是吗（/呲牙），不过知识点还似要补滴

全排列去重，判断满足条件的序列，找出字典序最小的

### 题解代码 ###

import java.util.HashSet;
    import java.util.Set;
    
    
    public class Main {
    
    //	static int[] b = {2,3,4,2,5,3,5,4};
    //	static int ans = 0;
    
    	public static void main(String[] args) {
    		char[] a = {'A', 'A', '2', '2', '3', '3', '4', '4'};
    		//全排列
    		fun(a,0);
    		for (String s : set) {
    			System.out.println(s);
    		}
    	}
    
    	static Set<String> set = new HashSet<String>();//用于去重
    	private static void fun(char[] a, int k) {
    		if (k == a.length) {
    			String s = new String(a);
    			if (check(s))
    				set.add(s);
    		}
    		for (int i = k; i < a.length; i++) {
    			char t = a[i];
    			a[i] = a[k];
    			a[k] = t;
    			
    			fun(a,k+1);//递归
    			//回溯
    			t = a[i];
    			a[i] = a[k];
    			a[k] = t;
    		}
    	}
    	//检测是否满足条件
    	private static boolean check(String s) {
    		if (s.lastIndexOf('A') - s.indexOf('A') == 2 &&
    			s.lastIndexOf('2') - s.indexOf('2') == 3 &&
    			s.lastIndexOf('3') - s.indexOf('3') == 4 &&
    			s.lastIndexOf('4') - s.indexOf('4') == 5) {
    			return true;
    		}
    		return false;
    	}
    
    }

### 答案 ###

2342A3A4

# 第八题：分糖果 (程序7分) #

### Problem Description ###

有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏：

每个小朋友都把自己的糖果分一半给左手边的孩子。

一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。

反复进行这个游戏，直到所有小朋友的糖果数都相同为止。

你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少个糖果。

【格式要求】

程序首先读入一个整数N(2<N<100)，表示小朋友的人数。  
接着是一行用空格分开的N个偶数（每个偶数不大于1000，不小于2）  
要求程序输出一个整数，表示老师需要补发的糖果数。

例如：输入  
3  
2 2 4  
程序应该输出：  
4

资源约定：  
峰值内存消耗（含虚拟机） < 256M  
CPU消耗 < 1000ms  
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
注意：主类的名字必须是：Main，否则按无效代码处理。

### 解题代码 ###

import java.util.Scanner;
    
    
    public class Main {
    
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		int n = in.nextInt();
    		int[] a = new int[105];
    		for (int i = 0; i < n; i++) {
    			a[i] = in.nextInt();
    		}
    		int ans = 0;
    		//模拟
    		while (true) {
    			int t = a[0];
    			for (int i = 0; i < n-1; i++) {
    				a[i] -= a[i]/2;//先去掉一半
    				a[i] += a[i+1]/2;//再加上左边给的糖果
    			}
    			a[n-1] -= a[n-1]/2;
    			a[n-1] += t/2;
    			int flag = 0;
    			for (int i = 0; i < n; i++) {
    				if (a[i] != a[0]) { //每个人糖果不相同的情况
    					flag = 1;
    				}
    				if(a[i] % 2 != 0) { //糖果数量不是偶数的小朋友
    					flag = 1;
    					a[i] += 1;
    					ans++;
    				}
    			}
    			if (flag == 0) {
    				break;
    			}
    		}
    		System.out.println(ans);
    		
    	}
    }

# 第九题：地宫取宝 (程序18分) #

### Problem Description ###

X 国王有一个地宫宝库。是 n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。

地宫的入口在左上角，出口在右下角。

小明被带到地宫的入口，国王要求他只能向右或向下行走。

走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。

当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明。

请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这k件宝贝。

【数据格式】

输入一行3个整数，用空格分开：n m k (1<=n,m<=50, 1<=k<=12)

接下来有 n 行数据，每行有 m 个整数 Ci (0<=Ci<=12)代表这个格子上的宝物的价值

要求输出一个整数，表示正好取k个宝贝的行动方案数。该数字可能很大，输出它对 1000000007 取模的结果。

例如，输入：  
2 2 2  
1 2  
2 1  
程序应该输出：  
2

再例如，输入：  
2 3 2  
1 2 3  
2 1 5  
程序应该输出：  
14

资源约定：  
峰值内存消耗（含虚拟机） < 256M  
CPU消耗 < 2000ms  
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

### 解题代码 ###

import java.util.Scanner;
    
    public class Main {
    
    	static int[][] a = new int[55][55],flag = new int[55][55];
    	static int ans = 0,n,m,k;
    
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		n = in.nextInt();
    		m = in.nextInt();
    		k = in.nextInt();
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < m; j++) {
    				a[i][j] = in.nextInt();
    			}
    		}
    		bfs(0,0,-1,0);//-1记录的是宝贝的价值
    		System.out.println(ans);
    		
    		
    	}
    
    	private static void bfs(int i, int j, int max, int x) {
    		int cur = a[i][j];//当前宝贝的价值
    		if(i >= n || j >= m || x > k) {
    			return;
    		}
    		if(i == n-1 && j == m-1 ) {//走到出口
    			if (x == k || (x == k-1 && cur > max)) {
    				ans++;
    				ans = ans % 1000000007;
    			}
    			
    		}
    		//当前宝贝的价值大，并且要拿起它的情况
    		if(cur > max) {
    			bfs(i+1,j,cur,x+1);
    			bfs(i, j+1, cur, x+1);
    		}
    		//当前宝贝价值小或价值大但不拿当前宝贝的情况
    		bfs(i, j+1, max, x);
    		bfs(i+1, j, max, x);
    	}
    }

注意：这样写只能得到一部分分值，因为m、n最大是50，而且每个格子都有4种情况，这样写的话bfs递归的时候会超时，因此需要将递归改成记忆性递归，若当前的状态跟前一个的状态是有关系的时候就可以使用记忆性递归。

import java.util.Scanner;
    
    public class Main {
    
    	static int[][] a = new int[55][55],flag = new int[55][55];
    	static int n,m,k;
    	static int[][][][] dp = new int[55][55][15][15];
    
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		n = in.nextInt();
    		m = in.nextInt();
    		k = in.nextInt();
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < m; j++) {
    				a[i][j] = in.nextInt();
    			}
    		}
    		//初始化dp
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < m; j++) {
    				for (int j2 = 0; j2 < 15; j2++) {
    					for (int k = 0; k <= Main.k; k++) {
    						dp[i][j][j2][k] = -1;
    					}
    				}
    			}
    		}
    		int sum = bfs(0,0,-1,0);
    		System.out.println(sum);
    		
    		
    	}
    
    	private static int bfs(int i, int j, int max, int x) {
    		if (dp[i][j][max+1][x] != -1) {
    			return dp[i][j][max+1][x];
    		}
    		int cur = a[i][j];
    		int ans = 0;
    		if(i >= n || j >= m || x > k) {
    			return 0;
    		}
    		if(i == n-1 && j == m-1 ) {//小明走到出口
    			if (x == k || (x == k-1 && cur > max)) {
    				return 1;
    			}else {
    				return 0;
    			}
    		}
    		//当前宝贝的价值比小明手中任意宝贝价值都大，并且拿起它的情况
    		if(cur > max) {
    			ans += bfs(i+1,j,cur,x+1);
    			ans = ans % 1000000007;//每次ans加了之后必须要取余
    			ans += bfs(i, j+1, cur, x+1);
    			ans = ans % 1000000007;
    		}
    		//当前宝贝价值小或价值大但不拿当前宝贝的情况
    		ans += bfs(i, j+1, max, x);
    		ans = ans % 1000000007;
    		ans += bfs(i+1, j, max, x);
    		ans = ans % 1000000007;
    		dp[i][j][max+1][x] = ans % 1000000007;
    		return dp[i][j][max+1][x];
    	}
    }

# 第十题：矩阵翻硬币 (程序23分) #

### Problem Description ###

小明先把硬币摆成了一个 n 行 m 列的矩阵。

随后，小明对每一个硬币分别进行一次 Q 操作。

对第x行第y列的硬币进行 Q 操作的定义：将所有第 i\*x 行，第 j\*y 列的硬币进行翻转。

其中i和j为任意使操作可行的正整数，行号和列号都是从1开始。

当小明对所有硬币都进行了一次 Q 操作后，他发现了一个奇迹——所有硬币均为正面朝上。

小明想知道最开始有多少枚硬币是反面朝上的。于是，他向他的好朋友小M寻求帮助。

聪明的小M告诉小明，只需要对所有硬币再进行一次Q操作，即可恢复到最开始的状态。然而小明很懒，不愿意照做。于是小明希望你给出他更好的方法。帮他计算出答案。

【数据格式】  
输入数据包含一行，两个正整数 n m，含义见题目描述。  
输出一个正整数，表示最开始有多少枚硬币是反面朝上的。

【样例输入】  
2 3

【样例输出】  
1

【数据规模】  
对于10%的数据，n、m <= 10^3；  
对于20%的数据，n、m <= 10^7；  
对于40%的数据，n、m <= 10^15；  
对于100%的数据，n、m <= 10^1000（10的1000次方）。

资源约定：  
峰值内存消耗（含虚拟机） < 256M  
CPU消耗 < 2000ms  
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

### 解题思路 ###

1.假设某个格子的行为x，列为y，要想知道这个格子最开始是反是正，就要知道它一共被翻了多少次，如果翻了奇数次，那么刚开始就是反面，如果被翻了偶数次，那刚开始就是正面；

2.辣么问题来了，一共被翻了多少次呢？要想知道它被翻了多少次，就得先知道x有多少个真因子t\_x以及y有多少个真因子t\_y，而这个硬币被翻的总次数就是t\_x \* t\_y；（对第x行第y列的硬币进行 Q 操作的定义：将所有第 i\*x 行，第 j\*y 列的硬币进行翻转。注意：i 和 j 并不一定相等）

3.要想被翻的次数是奇数，即t\_x \* t\_y是奇数，辣么t\_x和t\_y必定都是奇数；然而我们都知道一个数的真因子的个数是奇是偶取决于这个数是否为平方数（我 并不知道~）；如果是平方数，真因子个数就是奇数，否则为偶数个；（例如9,10,16,20）

4.所以所有格子中只有x 和 y是平方数的硬币一开始是反面的，也就是说 n 中平方数的个数和 m 中平方数的个数的乘积就是反面硬币的个数，假设n 中平方数的个数为S\_n，m 中平方数的个数为S\_m，即求S\_n \* S\_m；

5.然而我们都知道一个数n，它的平方数的个数是![\\sqrt\{n\}][sqrt_n]（这个，我也不知道~），所以这道题的问题就变成了求![\\sqrt\{n\}\\ast \\sqrt\{m\}][sqrt_n_ast _sqrt_m]；（例如10的平方数的个数为3,16的平方数的个数为4...）

6.辣么问题又来了，n和m很大（n、m <= 10^1000）用long根本存不下，怎么办？这里又涉及到一个知识点，假如一个数n，它的长度是len（即几位数），如果len是偶数的话，![\\sqrt\{n\}][sqrt_n]的长度是![\\frac\{len\}\{2\}][frac_len_2]，如果是奇数的话，![\\sqrt\{n\}][sqrt_n]的长度是![\\frac\{len\}\{2\}+1][frac_len_2_1]（这个 我更不知道）；

7.辣么知道![\\sqrt\{n\}][sqrt_n]和![\\sqrt\{m\}][sqrt_m]的长度之后有什么用呢？知道了他们的长度之后，我们就可以缩小范围，比如我们知道了![\\sqrt\{n\}][sqrt_n]是2位数，那我们就可以从10开始猜，然后20,30,40...，找到十位数之后，再循环找个位数，知道这个数的平方是n

8.到这思路就要收工了，下面开启代码工作

### 题解代码 ###

import java.math.BigInteger;
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class Main {
    
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		String s1 = in.next();//n
    		String s2 = in.next();//m
    		BigInteger b1 = sqrt(s1);//根号n
    		BigInteger b2 = sqrt(s2);//根号m
    		//结果是根号n和根号m的乘积
    		System.out.println(b1.multiply(b2));
    		
    		
    	}
    
    	private static BigInteger sqrt(String s) {
    		BigInteger n = new BigInteger(s);
    		int length = s.length();
    		int len = 0;//记录根号n是几位数
    		if (length % 2 == 0) {
    			len = length/2;
    		} else {
    			len = length/2 + 1;
    		}
    		char[] a = new char[len];//用字符串存储根号n
    		Arrays.fill(a, '0');//字符串用0填充
    		//下面开始从根号n的最高位开始猜
    		for (int i = 0; i < len; i++) {
    			//每一位的数都是由1~9的数字组成的
    			for (char j = '1'; j <= '9'; j++) {
    				a[i] = j;
    				BigInteger t = new BigInteger(String.valueOf(a));
    				BigInteger pow = t.pow(2);
    				//判断这个数的平方是否比n大,就说明找到了这个数
    				if (pow.compareTo(n) == 1) {
    					a[i] -= 1;
    					break;
    				}
    			}
    		}
    		BigInteger b = new BigInteger(String.valueOf(a));
    		return b;
    		
    	}
    
    	
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTgxNzcy_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200303171908392.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTgxNzcy,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTgxNzcy_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200303171240460.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTgxNzcy,size_16,color_FFFFFF,t_70
[20190227152058570.PNG]: https://img-blog.csdnimg.cn/20190227152058570.PNG
[sqrt_n]: https://private.codecogs.com/gif.latex?%5Csqrt%7Bn%7D
[sqrt_n_ast _sqrt_m]: https://private.codecogs.com/gif.latex?%5Csqrt%7Bn%7D%5Cast%20%5Csqrt%7Bm%7D
[frac_len_2]: https://private.codecogs.com/gif.latex?%5Cfrac%7Blen%7D%7B2%7D
[frac_len_2_1]: https://private.codecogs.com/gif.latex?%5Cfrac%7Blen%7D%7B2%7D&plus;1
[sqrt_m]: https://private.codecogs.com/gif.latex?%5Csqrt%7Bm%7D