【蓝桥杯】Java_B组2014年省赛真题

01武功秘籍

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

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

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

• 答案：7

• 按照要求在同一张纸上的是 0/1 ，2/3，4/5，6/7，8/9，¦ 10/11，…

  可以看到只看页码个位数上的数即可，直接数可以数出是7张。

 

02切面条

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

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

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

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

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

• 答案：1025

• 拿张纸对折三次撕（bushi） 在纸上画线，折几次曲线弯曲折叠几次，然后中间画一条切线，可以得到连续对折3次时，切一刀可得9根面条；

  观察归纳可得：连续对折 n 次，中间切一刀，会得到 2 ⁿ + 1 根面条。

 

03猜字母

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

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

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

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

• 答案：q

public static void main(String[] args) {
    // 按要求拼接字母
    String s = "abcdefghijklmnopqrs";
    StringBuilder sb = new StringBuilder(s);
    for(int i = 0; i < 106; i++) {
        sb.append(s);
    }

    while(sb.length() != 1){
        for(int i = 0; i < sb.length(); i += 2) {
            sb.replace(i, i + 1, "0");	// 先将奇数位替换为0
        }
        String[] temp = sb.toString().split("0");	// 借助Stirng数组去除0
        String t = "";
        for(int j = 0; j < temp.length;j++){	// 重新拼接为字符串
            t += temp[j];
        }
        sb = new StringBuilder(t);	// 将字符串再次转为StringBuilder型
    }
    System.out.println(sb.toString());
}

 

04大衍数列

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

它的前几项是：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
  

 

05圆周率

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

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

下面的程序实现了该求解方法。实际上数列的收敛对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", ______________));

• 答案：

  4 / ( x - 1 )
  

 

06奇怪的分式

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

1/4 乘以 8/5

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

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

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

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

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

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

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

• 答案：14

• 方法：枚举，计算直接拼接的分子分母约分后是否和真实答案相同

  public class B_06奇怪分式 {
  
  public static void main(String[] args) {
  		int cnt = 0;
  		for(int ai = 1; ai <= 9; ai++) {	// 分子
  			for(int aj = 1; aj <= 9; aj++) {	// 分母
  				if(ai == aj) continue;
  				for(int bi = 1; bi <= 9; bi++) {	// 分子
  					for(int bj = 1; bj <= 9; bj++) {	// 分母
  						if(bi == bj)	continue;
  						int real_i = ai * bi, real_j = aj * bj;		// 真实分子分母
  						int m_i = ai * 10 + bi, m_j = aj * 10 + bj;	// 小明做法的分子分母
  						int r = gcd(real_i, real_j);	// 真实分子分母的最大公约数
  						int m = gcd(m_i, m_j);		// 小明做法的分子分母最大公约数
  						if(real_i / r == m_i / m && real_j / r == m_j / m)
  							cnt++;
  					}
  				}
  			}
  		}
  		System.out.println(cnt);
  	}
  	
  	public static int gcd(int a, int b) {
  		if(a % b == 0) return b;
  		return gcd(b, a % b);
  	}
  }
  

 

07扑克排序

A A 2 2 3 3 4 4， 一共4对扑克牌。请你把它们排成一行。

要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。

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

例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。

请通过浏览器提交答案。“A”一定不要用小写字母a，也不要用“1”代替。字符间一定不要留空格。

• 答案：2342A3A4
• 方法：参考13年省赛 “带分数” 题的做法
  • 对 A A 2 2 3 3 4 4 全排列，检查每一个排列是否复合要求，记录下来；
  • 由于扑克牌数组中每种元素有两张，全排列的结果有重复，使用集合类set进行去重；
  • 最终筛选出的结果中，字典序最小的即为答案。

import java.util.HashSet;
import java.util.Set;

public class B_07扑克排序 {
	static Set<String> set = new HashSet<>();	// 哈希集合set去重
	
	public static void main(String[] args) {
		char[] arr = {'A', 'A', '2', '2', '3', '3', '4', '4'};
		f(arr, 0);
		
		for (String s : set) {
			System.out.println(s);
		}
	}

	// 全排列递归模板
	private static void f(char[] arr, int k) {
		if(k == arr.length) {
			String s = new String(arr);
			check(s);
		
		}
		
		for(int i = k; i < arr.length; i++) {
			char t = arr[k];
			arr[k] = arr[i];
			arr[i] = t;
			
			f(arr, k + 1);
			
			t = arr[k];
			arr[k] = arr[i];
			arr[i] = t;
		}
		
	}

	private static void 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) {
			set.add(s);
		}
			
	}
}

 

08分糖果

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

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

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

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

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

格式要求：

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

例如：

输入
3
2 2 4
输出：
4

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

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

• 方法：模拟情景

  考虑小朋友围成圈的情况怎么实现。

import java.util.Arrays;
import java.util.Scanner;

public class B_08分糖果 {
	private static int count = 0;	// 老师给出糖果数
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int[] arr = new int[N];
		for(int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
		}

		while(true) {
			// 小朋友给糖果
			int firstGive = arr[0] / 2;		// 第一个小朋友应分给最后一个小朋友的个数
			for(int i = 0; i < N - 1; i++) {
				childGive(arr, i, arr[i + 1] / 2);
			}
			childGive(arr, N - 1, firstGive);	// 最后一个小朋友
			
			// 判断小朋友糖果数是否相同
			if(check(arr))	break;
			
			// 老师给糖果
			for(int i = 0; i < N; i++) {
				if(arr[i] % 2 != 0) {
					arr[i]++;
					count++;
				}
			}
		}
		
		System.out.println(count);
	}

	private static boolean check(int[] arr) {
		for(int i = 1; i < arr.length; i++) {
			if(arr[0] != arr[i])	return false;
		}
		return true;
	}

	/**
	 * 小朋友一轮分配
	 * @param arr		小朋友数组
	 * @param i			当前下标为i的小朋友
	 * @param receive	收到右边小朋友给的糖果
	 */
	private static void childGive(int[] arr, int i, int receive) {
		int give = arr[i] / 2; // 应给出的糖果数
		arr[i] += - give + receive;	// 给出和接收后的糖果数
	}
}

 

09地宫取宝（🙅‍）

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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

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

• 理解题意：
  • 与 2013 年JavaB组题目 振兴中华 类似 使用递归深搜，但是多了一些条件限制；
  • 当前格子中的宝贝价值比已拿的手中 任意宝贝 价值都大，才能拿或者不拿；
  • 到出口时宝贝数恰好是k件。
• 得分：42分

import java.util.Scanner;

public class B_09地宫取宝 {
	static int n;
	static int m;
	static int k;
	static int[][] arr;	// 宝藏价格
	static long ans;
	static int MOD = 1000000007;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		k = sc.nextInt();
		arr = new int[n][m];
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				arr[i][j] = sc.nextInt();
			}
		}
		
		dfs(0, 0, -1, 0);	// 第一个点价值可能是0,所以初始传入使用-1
		System.out.println(ans);
	}

	/**
	 * 递归深搜
	 * @param x		当前所在行
	 * @param y		当前所在列
	 * @param max	已取宝物中的最大值
	 * @param cnt	已取宝物数
	 * @return
	 */
	private static void dfs(int x, int y, int max, int cnt) {
		if(x == n || y == m)	return;
		int cur = arr[x][y];	// 当前位置
		if(x == n - 1 && y == m - 1) {	// 处于最后一个格子
//			if(cnt == k) 	ans++;	// 若宝物已拿满
//			if(cnt == k - 1 && cur > max)	ans++;	// 差一个宝物且当前宝物可拿
			if(cnt == k || (cnt == k - 1 && cur > max)) {
				ans++;
				if(ans > MOD)	ans %= MOD;		// 按要求对答案取模
			}
		}
		if(cur > max) {		// 可以取当前位置上的物品
			dfs(x, y + 1, cur, cnt + 1);
			dfs(x + 1, y, cur, cnt + 1);
		}
		// 当前位置物品价值小而不取,或价值大而不取
		dfs(x, y + 1, max, cnt);
		dfs(x + 1, y, max, cnt);
	}
}

• 改进：得分：100分

  • 在递归调用的结束条件中增加判断 取得宝藏数是否大于要求的k，大于则不用再进行下去，直接删除；

  • 存在重复子问题求解的情况：dfs传入的一个状态(x, y, max, cnt) 可能由它的上方或者左方行动而来，即会发生重复求一个状态的情况。使用 记忆型dp 可以解决。

import java.util.Scanner;

public class B_09地宫取宝 {
	static int n;
	static int m;
	static int k;
	static int[][] arr;	// 宝藏价格
	static long ans;
	static int MOD = 1000000007;
	static long[][][][] cache = new long[51][51][14][14];
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		k = sc.nextInt();
		arr = new int[n][m];
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				arr[i][j] = sc.nextInt();
			}
		}
		for (int i = 0; i < 51; i++) {
	      for (int j = 0; j < 51; j++) {
	        for (int l = 0; l < 14; l++) {	// 由于max初始为-1,为解决下标越界问题,长度为14
	          for (int o = 0; o < 14; o++) {
	            cache[i][j][l][o] = -1;
	          }
	        }
	      }
	    }
		
		long ans = dfs(0, 0, -1, 0);	// 第一个点价值可能是0,所以初始传入使用-1
		System.out.println(ans);
	}

	/**
	 * 递归深搜
	 * @param x		当前所在行
	 * @param y		当前所在列
	 * @param max	已取宝物中的最大值
	 * @param cnt	已取宝物数
	 * @return
	 */
	private static long dfs(int x, int y, int max, int cnt) {
		// 查记录,若该条路径已搜过,直接将状态返回
		if(cache[x][y][max + 1][cnt] != -1)	return cache[x][y][max + 1][cnt];	// max + 1是因为max初始传入为-1	
		if(x == n || y == m || cnt > k)	return 0;
		int cur = arr[x][y];	// 当前位置
		long ans = 0;	// 定义一个新的ans变量
		if(x == n - 1 && y == m - 1) {	// 处于最后一个格子
//			if(cnt == k) 	ans++;	// 若宝物已拿满
//			if(cnt == k - 1 && cur > max)	ans++;	// 差一个宝物且当前宝物可拿
			if(cnt == k || (cnt == k - 1 && cur > max)) {
				ans++;
				if(ans > MOD)	ans %= MOD;		// 按要求对答案取模
			}
			return ans;
		}
		if(cur > max) {		// 可以取当前位置上的物品
			ans += dfs(x, y + 1, cur, cnt + 1);
			ans += dfs(x + 1, y, cur, cnt + 1);
		}
		// 当前位置物品价值小而不取,或价值大而不取
		ans += dfs(x, y + 1, max, cnt);
		ans += dfs(x + 1, y, max, cnt);
		
		// 记录状态
		cache[x][y][max + 1][cnt] = ans % MOD;
		return ans % MOD;
	}
}

 

10矩阵翻硬币（🙅‍）

小明先把硬币摆成了一个 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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

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

• 理解题意：

  • 数据规模较大，使用模拟只能通过10%数据，模拟在该题不适用；

  • (x, y) 会被翻多少次？设为t次：

  x 的真因子有多少个？设为 t _x ；

  y 的真因子有多少个？设为 t _y ；

  t = t _x * t _y

  • t _x ， t _y 怎么求？

    x 是平方数，则 t _x 是奇数：eg ：t ₉ 真因子有 1，3，9，t ₉ = 3；

    否则， t _x 是偶数：eg ：t ₁₀ 真因子有 1，2，5，10，t ₁₀ = 4；

  • 若 t _x * t _y 是偶数，即原本是正面的翻了之后仍为正面，不是要计数的情况；

    即 t _x * t _y 是奇数，----> 说明一开始是反面；

    由 t _x * t _y 是奇数 ----> t _x ， t _y 分别是奇数 ----> x，y 都是平方数 ----> 求n中有多少个平方数 C _n ，m中有多少个平方数 C _m。

  • C _n = n ^1/2，C _m = m ^1/2 （向下取整），ans = sqrt(n) * sqrt(m)；

  • 若 n ∈ N，长度为length，则 sqrt(n)的长度（记为len） 为：

    若为奇数：length / 2 + 1

    若为偶数：length / 2

    eg：16，长度为2， length / 2 = 1，即 len = 1；

  • 通过len找到 sqrt(n)的办法：

    eg：1296 ( 36 * 36)，len = 2，从高位试起：

    10 ² ＜ 1296，20 ² ＜ 1296，30 ² ＜ 1296，40 ² ＞ 1296，因此高位为3；

    31 ² ＜ 1296，32 ² ＜ 1296，33 ² ＜ 1296，34 ² ＜ 1296，35 ² ＜ 1296，36 ² = 1296，37 ² ＞ 1296，因此sqrt(1296)为36。

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class B_10矩阵翻硬币 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s1 = sc.next();	// 规模比较大,所以用string
		String s2 = sc.next();
		System.out.println(sqrt(s1).multiply(sqrt(s2)));
	}

	private static BigInteger sqrt(String s) {
		int length = s.length();
		int len = 0;
		if(length % 2 == 0)	len = length / 2;
		else len = length / 2 + 1;
		
		char[] sArr = new char[len];	// 存储sqrt(n)各位
		Arrays.fill(sArr, '0');	 // 初始化为'0'
		BigInteger target = new BigInteger(s);	// n,要找其sqrt(n)的数
		
		for(int pos = 0; pos < len; pos++) {	// 从高位开始(0存储最高位)
			for(char c = '1'; c <= '9'; c++) {	// 试探每一位为多少
				sArr[pos] = c;
				// 将sArr转为字符串后再转为BigInteger类型进行平方运算
				BigInteger pow = new BigInteger(String.valueOf(sArr)).pow(2);
				if(pow.compareTo(target) == 1) {	// 试探数的平方更大
					sArr[pos] -= 1;
					break;
				}
			}
		}
		return new BigInteger(String.valueOf(sArr));
	}
}

 

参考：https://www.bilibili.com/video/BV1PX4y137yr?p=26