第五届蓝桥杯大赛个人省赛javaB组

1. 武功秘籍

小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他 意识到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。 小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？ 这是个整数，请通过浏览器提交该数字，不要填写任何多余的内容。

答案：7

 （10,11），（12,13），（14,15），（16,17），（18,19）

 （20,21）

  ...

  （80,81）， (82,83)，（84,85），（86,87），（88,89）

    （90,91），（92,93）

import java.util.Arrays;import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner in = new Scanner(System.in);int x = in.nextInt();int y = in.nextInt();System.out.println(getSum(x, y));}public static int getSum(int x, int y) {int sum = 0;if(x % 2 ==0 && y % 2 == 0) {sum = (y - x + 2) / 2;}else if(x % 2 == 0 && y %2 != 0) {sum = (y - x + 1) /2;}else if(x % 2 != 0 && y % 2 == 0) {sum = (y - x + 3) /2;}else {sum = (y - x + 2) / 2;}return sum;}}

2. 切面条

一根高筋拉面，中间切一刀，可以得到2根面条。 如果先对折1次，中间切一刀，可以得到3根面条。 如果连续对折2次，中间切一刀，可以得到5根面条。 那么，连续对折10次，中间切一刀，会得到多少面条呢？ 答案是个整数，请通过浏览器提交答案。不要填写任何多余的内容。

答案：1025

3 = pow(2,1) + 1

5 = pow(2,2) + 1

9 = pow(2,3) + 1

1025 = pow(2,10) + 1

3. 猜字母

把abcd...s共19个字母组成的序列重复拼接106次，得到长度为2014的串。 接下来删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。 得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。 答案是一个小写字母，请通过浏览器提交答案。不要填写任何多余的内容。

答案： q

import java.util.Arrays;import java.util.Scanner;public class Main {public static void main(String[] args) {//Scanner in = new Scanner(System.in);String list = "abcdefghijklmnopqrs";StringBuilder sb = new StringBuilder();for(int i = 1; i <= 106; i++) {sb.append(list);}while(sb.length() != 1) {StringBuilder temp = new StringBuilder();for(int i = 1; i <= sb.length(); i++) {if(i % 2 == 0) {temp.append(sb.charAt(i-1));}}sb = temp;}System.out.println(sb.toString());}}

4. 大衍数列

标题：大衍数列 中国古代文献中，曾记载过“大衍数列”, 主要用于解释中国传统文化中的太极衍生原理。 它的前几项是：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 

5. 圆周率

数学发展历史上，圆周率的计算曾有许多有趣甚至是传奇的故事。其中许多方法都涉及无穷级数。图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(   ); //填空

答案：4/(x-1) 

6. 奇怪的分式

      上小学的时候，小明经常自己发明新算法。一次，老师出的题目是： 1/4 乘以 8/5 小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png） 老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？ 请写出所有不同算式的个数（包括题中举例的）。 显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。 但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。

答案：14

import java.util.Arrays;import java.util.Scanner;public class Main {static double sum1,sum2;static int sum = 0;public static void main(String[] args) {for(int a = 1; a < 10; a++) {for(int b = 1; b < 10; b++) {for(int c = 1; c < 10; c++){for(int d = 1; d < 10; d++) {if(a != b && c != d) {sum1 = a / (b * 1.0) * c /(d * 1.0) ;sum2 = (a*10+c)/((b *10+ d) *1.0);if(Math.abs(sum1 - sum2) < 0.00000001) {System.out.println(sum1 + ":" + sum2);sum++;}}}}}}System.out.println(sum);}}

7. 扑克序列

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

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

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

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

答案：2342A3A4

  根据程序得到2342A3A4 和4A3A2432这两种排序，然后再根据字典序最小的那个的条件得到答案

import java.util.Arrays;import java.util.Scanner;public class Main {static String[] arr = {"A","A","2","2","3","3","4","4"};static int n = 8;static StringBuilder sb;public static void main(String[] args) {int offset = 0;//全排列dp(offset);}static void dp(int offset) {if(offset == n -1) {//得到数组arr[]进行处理deal();}for(int i = offset; i < n; i++) {swap(i, offset);dp(offset+1);swap(i, offset);}}static void deal() {sb = new StringBuilder();for(int i = 0; i < n; i++ ) {sb.append(arr[i]);}if(check("A") && check("2") && check("3")&& check("4")) {System.out.println(sb.toString());}}//判断是否符合条件static Boolean check(String arr2) {int a = sb.indexOf(arr2);int b = sb.lastIndexOf(arr2);int cha = b - a -1;if(arr2.equals("A")) {if(cha == 1) {return true;}else {return false;}}else if(arr2.equals("2")) {if(cha == 2) {return true;}else {return false;}}else if(arr2.equals("3")) {if(cha == 3) {return true;}else {return false;}}else if(arr2.equals("4")) {if(cha == 4) {return true;}else {return false;}}return false;}static void swap(int a, int b) {String temp = arr[a];arr[a] = arr[b];arr[b] = temp;}}

8. 分糖果

有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 Main {static int arr[];static int sum,n;public static void main(String[] args) {Scanner in = new Scanner(System.in);while(in.hasNext()) {sum = 0;n = in.nextInt();arr = new int[n];for(int i = 0; i < n; i++) {arr[i] = in.nextInt();}//判断是否相等while(check()) {//同学们分送和老师补奇数的同学given();}System.out.println(sum);}}static boolean check() {for(int i = 1; i < n; i++) {if(arr[i-1] != arr[i]) {return true;}}return false;}static void given() {arr[0] = arr[0]/2;int temp = arr[0];for(int i= 1; i < n; i++) {arr[i-1] += arr[i]/2;arr[i] = arr[i]/2;}arr[n-1] += temp;//老师给奇数个的同学for(int i = 0; i < n; i++) {if(arr[i] % 2 != 0) {arr[i]++;sum++;}}}}

9. 地宫取宝

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，否则按无效代码处理。 

 

import java.util.ArrayList;import java.util.Arrays;import java.util.List;import java.util.Scanner;public class Main {static int n, m ,k,countk; //countk是第二次深受时用来保存捡了几个宝藏的数static int[][]arr;static int[][]visited;  //1代表访问过了，0代表未访问static List<Integer> list;  //保存经过宝藏的地点的宝藏static int listlength;static int sum, max;public static void main(String[] args) {Scanner in = new Scanner(System.in);while(in.hasNext()) {n = in.nextInt();m = in.nextInt();k = in.nextInt();arr = new int[n][m];visited = new int[n][m];for(int i = 0; i < n; i++) {for(int j = 0; j < m; j++) {visited[i][j] = 0;arr[i][j] = in.nextInt();}}sum = 0;visited[0][0] =1;dp(0, 0);  //开始深搜System.out.println(sum);}}static void dp(int a, int b) {if(a==n-1 && b== m-1) {//对获取到的路径再次进行深搜处理deal();return;}if(a != n-1&& b != m-1) {visited[a][b+1] = 1;dp(a, b+1);visited[a][b+1] = 0;visited[a+1][b] = 1;dp(a+1,b);visited[a+1][b] = 0;}else if(a != n-1 && b == m-1) {visited[a+1][b] = 1;dp(a+1,b);visited[a+1][b] = 0;}else {visited[a][b+1] = 1;dp(a, b+1);visited[a][b+1] = 0;}}static void deal() {//获取经过点的宝藏的种类和值list = new ArrayList<Integer>();for(int i = 0; i < n; i++) {for(int j = 0; j < m; j++) {if(visited[i][j] == 1) {list.add(arr[i][j]);}}}listlength = list.size();countk = 0;max = 0;dp2(0);}static void dp2(int index) {if(index == listlength) {if(countk == k) {sum++;sum %= 1000000007; //记得对结果取模}return ;}if(list.get(index) > max) {int temp = max;max = list.get(index);countk++;dp2(index+1);max = temp;countk--;dp2(index+1);}else {dp2(index+1);}}}

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； 对于10%的数据，n、m <= 10^1000（10的1000次方）。

 资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 2000ms 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...”的多余内容。 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。 注意：主类的名字必须是：Main，否则按无效代码处理。

答案： 

题目解析：　　

　　1、从题目得知，如果一个硬币被翻转了奇数次后为正面朝上，那么它原始的状态一定是反面朝上。因此，我们需要统计所有翻转了奇数次硬币的个数。

　　2、题目中的 “ 对第x行第y列的硬币进行 Q 操作的定义：将所有第 i*x 行，第 j*y 列的硬币进行翻转 ”。我们可以试着逆向思索，对于一个横坐标为X的硬币而言，我们翻转哪些硬币会影响到它而使它翻转呢？由此我们可以得出，当翻转的硬币的横坐标为X的约数时，会影响到它的翻转。比如，X=9，那么翻转横坐标为 1、3、9的时候会影响到它的翻转。纵坐标情况同理。

　　 　对于一个硬币，我们必须考虑到它的横坐标和纵坐标。假如，此硬币的横坐标翻转了5次，纵坐标翻转了6次，那么它总的翻转次数为 5 * 6 = 30 次。因此我们得到一个公式：总翻转次数 (count) = 横坐标翻转次数 (count_x) * 纵坐标翻转次数 (count_y)。我们一开始就指出，我们需要找到翻转了奇数次的硬币，因此，横坐标翻转次数和纵坐标翻转次数均为奇数时，总翻转次数才为奇数次。

　　3、接下来我们需要考虑，哪些数有奇数个约数呢？答案是完全平方数。它为 1,4,9,16,25,36...... 即n的2次方，n为从1开始的正整数。

　　　 从题目中得知，此时是一个 n * m 的矩阵，行号和列号都是从1开始。因此我们需要解决 1 到 n 之间完全平方数个数的问题。方法是求出sqrt(n)，然后对它取整，即 1 - n 之间总共有 (int)(sqrt(n)) 个完全平方数。因此，反面朝上硬币的个数为横纵坐标完全平方数个数相乘，即 (int)((sqrt(n)) * (sqrt(m))) 。

　　4、由于此题的数据是超大规模的。因此，我们需要解决大数开方、大数相乘和大数比较等问题。

　　　 通常使用 String 来接受键盘输入大数，因为它的长度比较容易控制。而使用 java.math.BigInteger 包中的 BigInteger 类来存储大数据。它的原则是，只要计算机有足够的的内存，它就能存储多长位数的数。

　　　大数开方： 牛顿逼近法。

　　　　　　　　如果一个数的位数为偶数，那么这个数的方根就有 n/2 位，如果一个数的位数为奇数，这个数的方根就有 n/2 + 1 位。

　　　　　　　　比如 num=1000 ，那么它的位数为 4 ，即方根就有 2 位。我们从方根的最高位进行枚举。

　　　　　　　　　　先枚举出它的十位：

　　　　　　　　　　　　10 * 10 = 100 < 1000

　　　　　　　　　　　　20 * 20 = 400 < 1000

　　　　　　　　　　　　30 * 30 = 900 < 1000

　　　　　　　　　　　　40 * 40 = 1600 > 1000

　　　　　　　　　　则这个根的十位为 3 。

　　　　　　　　　　再枚举它的个位：

　　　　　　　　　　　　31 * 31 = 961 < 1000

　　　　　　　　　　　　32 * 32 = 1024 > 1000

　　　　　　　　　　则这个根的个位为 1 。即这个方根为 31 。

　　　大数相乘：调用 java.math.* 包中的 multiply 方法。比如 bigNum1.multiply(bigNum2)

　　　　　　　　 在 c 语言或者 c++ 语言中没有 BigInteger 类，因此我们在考虑大数相乘的时候，需要解决移位和进位的问题。比如，在运算12 * 34 时，我们在演草纸上怎样进行计算的呢? 首先 2 * 4 = 8 没有进位，因此结果值的个位为 8 ，接下来 1 * 4 = 4 、 2 * 3 = 6 ， 4 + 6 = 10 ，有进位，进 1 后结果值的十位为 0 ，然后 1 * 3 = 3 ，再加上刚才的进位 1 ，所以结果值的百位为 4 ，即最后的值为 408 。这是我们正常的计算方法，但我们需要考虑这种简单粗暴的方法怎样在计算机中实现。因此，我们这时想到将数放在数组中是一个很好的方法。比如，我们将 12 和 34 分别放在char型数组a和数组b中，结果放在数组 c 中。所以计算过程如下：

　　　　　　　　　　　a: { 1 , 2 }    b：{ 3 , 4}

　　　　　　　　　　　a[1] * b[1] = 2 * 4 = 8

　　　　　　　　　　　a[0] * b[1] = 1 * 4 = 4

　　　　　　　　　　　a[1] * b[0] = 2 * 3 = 6

　　　　　　　　　　　a[0] * b[0] = 1 * 3 = 3

　　　　　　　　　　　c：{ 3 , 10 , 8 }  →  { 4 , 0  , 8 }

　　　　　　　　但是此时我们发现在数组中进行进位时是一件十分麻烦的事，因为若数非常大的时候，比如最后的结果出现了 { 9 , 12 , ... , 8}，加入此数是一个 1000 0000 位的数，我们发现当最高位需要进位的时候，需要将这所有存储单位中的数右移一位，也就是需要移动 1000 0000 次，所以解决此问题的最好办法是将数在数组中逆序存储，当最高位需要进位的时候，只需要在最高位后再申请一个存储单元即可，也就是一定一次就可以了。比如计算 56 * 78 时，

 

　　　　　　　　　　　a: { 6, 5 }    b：{8 , 7}

 

　　　　　　　　　　　a[0] * b[0] = 6 * 8 = 48

 

　　　　　　　　　　　a[1] * b[0] = 5 * 8 = 40

 

　　　　　　　　　　　a[0] * b[1] = 6 * 7 = 42

 

　　　　　　　　　　　a[1] * b[1] = 5 * 7 = 35

 

　　　　　　　　　　　c：{ 48 , 82 , 35 }  →  { 8 , 86  , 35 }  →  { 8 , 6  , 43 }  →  { 8 , 6  , 3 , 4 }

　　　　　　　　即 56 * 78 = 4368 。从移位和进位问题中我们就可以推敲出其规律来。所以，在解决大数相乘的时候，我们可以利用此方法来实现。

　　　　　　　

　　　大数比较： 调用 java.math.* 包中的 compareTo 方法，随第一个参数小于，等于或大于第二个参数返回负整数、零或正整数。比如 "2".compareTo ("3")

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.math.BigInteger;import java.util.Arrays;public class Main {    public static void main(String[] args) throws IOException {        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));        String[] str = br.readLine().split(" ");        String n =     str[0];        String m =     str[1];        BigInteger answer = (bigSqrt(n)).multiply(bigSqrt(m));   //sqrt(n) * sqrt(m)  1-n之间的完全平方数的个数 * 1-m之间完全平方数的个数        System.out.println(answer);    }    //  求1 - num 之间完全平方数的个数    private static BigInteger bigSqrt(String num) {        int length = num.length();     //被开方数的位数        int sqrt_len = 0;            //开方数的位数        if(length % 2 == 0){            sqrt_len = length / 2;        }else{            sqrt_len = length / 2 + 1;        }        BigInteger beSqrtNum = new BigInteger(num);        char[] ch = new char[sqrt_len];            //记录开方数，开房数在数组中逆序存放        Arrays.fill(ch, '0');                      //将ch数组初始化为'0'        for(int i = 0; i < sqrt_len; i++){         //从开房数的最高位开始计算，使 每一位都转化为 开方数的平方且不大于被开方数            for(char j = '1'; j <= '9'; j++ ){                ch[i] = j;                String s = String.valueOf(ch);                BigInteger sqrtNum = new BigInteger(s);                BigInteger squareNum = sqrtNum.multiply(sqrtNum);                if(squareNum.compareTo(beSqrtNum) == 1){     //大数比较问题                    ch[i] -= 1;                    break;                }            }        }        return new BigInteger(String.valueOf(ch));    }}