蓝桥杯2016年JavaB组省赛（代码+解析）

第一题：煤球数目

有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
…
如果一共有100层，共有多少个煤球？

请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
答案：171700
解析：
观察规律可知，第n层的煤球数目等于n-1层的煤球数目加上n
f(n)=f(n-1)+n

public static void main(String[] args) {int[] a=new int[101];a[1]=1;int sum=1;for(int i=2;i<=100;i++) {a[i]=a[i-1]+i;sum+=a[i];        }System.out.println(sum);}

第二题：生日蜡烛

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。

现在算起来，他一共吹熄了236根蜡烛。

请问，他从多少岁开始过生日party的？

请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
答案：26
分析：
暴力搜索，枚举开始过生日的年龄与现在的年龄

public static void main(String[] args) {      for(int i=1;i<=100;i++) {   for(int j=i;j<=100;j++) {int sum=0;sum=(i+j)*(j-i+1)/2;if(sum==236) {System.out.println(i);}}}}

第三题：凑算式

（如果显示有问题，可以参见【图1.jpg】）

这个算式中A_I代表19的数字，不同的字母代表不同的数字。

比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？

注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
答案：29
分析：
考察全排列+通分
设定一个数组a={1,2,3,4,5,6,7,8,9}
下标0-8分别表示A-I
对数组a进行全排列对于每一次的排列，检查其是否符合题目要求。

static int[] a= {1,2,3,4,5,6,7,8,9};static int count=0;static boolean check() {int x=a[3]*100+a[4]*10+a[5];int y=a[6]*100+a[7]*10+a[8];if((a[1]*y+a[2]*x)%(a[2]*y)==0&& a[0]+(a[1]*y+a[2]*x)/(a[2]*y)==10) {return true;}return false;}static void f(int k) {if(k==9) {if(check()) {count++;}         }for(int i=k;i<9;i++) {int t=a[i];a[i]=a[k];a[k]=t;f(k+1);t=a[i];a[i]=a[k];a[k]=t;}}public static void main(String[] args) {f(0);System.out.println(count);}

第四题：分小组

9名运动员参加比赛，需要分3组进行预赛。
有哪些分组的方案呢？

我们标记运动员为 A,B,C,… I
下面的程序列出了所有的分组方法。

该程序的正常输出为：
ABC DEF GHI
ABC DEG FHI
ABC DEH FGI
ABC DEI FGH
ABC DFG EHI
ABC DFH EGI
ABC DFI EGH
ABC DGH EFI
ABC DGI EFH
ABC DHI EFG
ABC EFG DHI
ABC EFH DGI
ABC EFI DGH
ABC EGH DFI
ABC EGI DFH
ABC EHI DFG
ABC FGH DEI
ABC FGI DEH
ABC FHI DEG
ABC GHI DEF
ABD CEF GHI
ABD CEG FHI
ABD CEH FGI
ABD CEI FGH
ABD CFG EHI
ABD CFH EGI
ABD CFI EGH
ABD CGH EFI
ABD CGI EFH
ABD CHI EFG
ABD EFG CHI
… (以下省略，总共560行)。

public class A
{
public static String remain(int[] a)
{
String s = “”;
for(int i=0; i<a.length; i++){
if(a[i] == 0) s += (char)(i+‘A’);
}
return s;
}
public static void f(String s, int[] a)
{
for(int i=0; i<a.length; i++){
if(a[i]==1) continue;
a[i] = 1;
for(int j=i+1; j<a.length; j++){
if(a[j]==1) continue;
a[j]=1;
for(int k=j+1; k<a.length; k++){
if(a[k]==1) continue;
a[k]=1;
System.out.println(__________________________________); //填空位置
a[k]=0;
}
a[j]=0;
}
a[i] = 0;
}
}
public static void main(String[] args)
{
int[] a = new int[9];
a[0] = 1;
for(int b=1; b<a.length; b++){
a[b] = 1;
for(int c=b+1; c<a.length; c++){
a[c] = 1;
String s = “A” + (char)(b+‘A’) + (char)(c+‘A’);
f(s,a);
a[c] = 0;
}
a[b] = 0;
}
}
}

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。
答案：s+" “+(char)(i+‘A’) + (char)(j+‘A’)+ (char)(k+‘A’)+” "+remain(a)

第五题抽签

X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
…

那么最终派往W星的观察团会有多少种国别的不同组合呢？

下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
…
(以下省略，总共101行)

public class A
{
public static void f(int[] a, int k, int n, String s)
{
if(ka.length){
if(n0) System.out.println(s);
return;
}
String s2 = s;
for(int i=0; i<=a[k]; i++){
_____________________________; //填空位置
s2 += (char)(k+‘A’);
}
}
public static void main(String[] args)
{
int[] a = {4,2,2,1,1,3};
f(a,0,5,"");
}
}

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。
答案：f(a, k+1, n-i, s2)

第六题：方格填数

如下的10个格子

（如果显示有问题，也可以参看【图1.jpg】）

填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）

一共有多少种可能的填数方案？

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：1580
分析：
将方格中的数，用数组来表示，从上到下，从左到右，依次为a0-a9
那么，问题就化为将数组进行全排列，然后对于每一种排列，检查是否符合题目要求。要求：连续的两个数字不能相邻。（左右、上下、对角都算相邻）就对相邻的数字进行判断，如果相差为1，就表明两个数字连续，那么这种情况就不能要。

static int[] a= {0,1,2,3,4,5,6,7,8,9};static int ans;static boolean check() {if(        Math.abs(a[0]-a[1])==1||Math.abs(a[0]-a[4])==1||Math.abs(a[0]-a[3])==1||Math.abs(a[0]-a[5])==1||Math.abs(a[1]-a[2])==1||Math.abs(a[1]-a[4])==1||Math.abs(a[1]-a[6])==1||Math.abs(a[1]-a[5])==1||Math.abs(a[2]-a[6])==1||Math.abs(a[2]-a[5])==1||Math.abs(a[3]-a[4])==1||Math.abs(a[3]-a[8])==1||Math.abs(a[3]-a[7])==1||Math.abs(a[4]-a[8])==1||Math.abs(a[4]-a[7])==1||Math.abs(a[4]-a[9])==1||Math.abs(a[4]-a[5])==1||Math.abs(a[5]-a[6])==1||Math.abs(a[5]-a[8])==1||Math.abs(a[5]-a[9])==1||Math.abs(a[6]-a[9])==1||Math.abs(a[7]-a[8])==1||Math.abs(a[8]-a[9])==1 ) return false;return true;} static void f(int k) {if(k==10) {boolean b=check();if(b) {ans++;  }          }for(int i=k;i<10;i++) {{int t=a[i];a[i]=a[k];a[k]=t;}f(k+1);{int t=a[i];a[i]=a[k];a[k]=t;}}   }public static void main(String[] args) {f(0);System.out.println(ans);}

第七题：剪邮票

如【图1.jpg】, 有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）

比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
答案：116
分析：
考察的是全排列，不重复的全排列，从12个位置中抽取5个。
然后判断每一次抽取的5个位置是否是连通的。

static int[] a= {0,0,0,0,0,0,0,1,1,1,1,1};//它的每个排列  代表着12选5的方案static int ans;static boolean[] vis=new boolean[12];static void dfs(int[][] g,int i,int j) {g[i][j]=0;if(i-1>=0&&g[i-1][j]==1)dfs(g, i-1, j);if(i+1<=2&&g[i+1][j]==1)dfs(g, i+1, j);if(j-1>=0&&g[i][j-1]==1)dfs(g, i, j-1);if(j+1<=3&&g[i][j+1]==1)dfs(g, i, j+1);}static boolean check(int[] path) {//将某个排列映射到二维矩阵上int[][] g=new int[3][4];     for(int i=0;i<3;i++) {for(int j=0;j<4;j++) {if(path[i*4+j]==1) {g[i][j]=1;}else g[i][j]=0;}}int cnt=0;//连通块的数目
// g上面就有5个格子被标记为1，现在才用dfs做连通性检查，要求只有一个连通块for(int i=0;i<3;i++) {for(int j=0;j<4;j++) {if(g[i][j]==1) {dfs(g,i,j);cnt++;}}}return cnt==1;//用dfs遍历一个块的四个相邻块，如果相邻块被选中即，g[i][j]=1//那么就将g[i][j]=0  因此 如果是连通的，那么经过dfs的遍历之后，所有的g[i][j]都为0//因此，只需判断cnt是否为1即可判断是否是连通块}static void f(int k,int[] path) {if(k==12) {if(check(path))ans++;}for(int i=0;i<12;i++) {//现在准备选取的元素与上一个元素相同，但上一个元素还没被使用if(i>0 && a[i]==a[i-1] && !vis[i-1])continue;if(!vis[i]) {  //没有用过的元素可以抓入到pathvis[i]=true;  //标记为已访问path[k]=a[i]; //将a[i]加入到path[k]中f(k+1, path);vis[i]=false;               }   }}public static void main(String[] args) {int[] path=new int[12];f(0,path);System.out.println(ans);}

第八题：四平方和

四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。

比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）

对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法

程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开

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

再例如，输入：
12
则程序应该输出：
0 2 2 2

再例如，输入：
773535
则程序应该输出：
1 1 267 838

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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
分析：
枚举a,b,c,d 但是如果用for循环的话，肯定是会超时的。
因为0 <= a <= b <= c <= d
所以可以先枚举c跟d,因为d>=c,所以c的平方不能超过n/2 因为如果大于，那么,d的平方就肯定会大于n/2 两个加起来就已经超过n了，不符合要求。
将cc+dd的值对应的c 存入到map中，以便用n-aa-bb就可以求出c的值。
下面就是枚举a,b。aa+bb的值肯定不能超过n/2，如果超过，那么cc+dd肯定也超过n/2，那么就不符合要求了，所以aa要小于n/4
枚举a跟b
再通过n-aa-bb可以得到cc+dd的值，这个值在枚举c,d的时候已经存入map中了，可以通过map来get到c的值，所以d就等于n-aa-bb-cc
最后输出结果

static Map<Integer, Integer> map=new HashMap<Integer, Integer>();static int n;public static void main(String[] args) {Scanner sc=new Scanner(System.in);n=sc.nextInt();for(int c=0;c*c<n/2;c++) {for(int d=c;d*d+c*c<n;d++) {if(map.get(c*c+d*d)==null) {map.put(c*c+d*d, c);}}          }for(int a=0;a*a<n/4;a++) {for(int b=a;b*b+a*a<n/2;b++) {if(map.get(n-a*a-b*b)!=null) {int c=map.get(n-a*a-b*b);int d=(int)Math.sqrt(n-a*a-b*b-c*c);System.out.println(a+" "+b+" "+c+" "+d);return;}}}      }

第九题：取球博弈

两个人玩取球的游戏。
一共有N个球，每人轮流取球，每次可取集合{n1,n2,n3}中的任何一个数目。
如果无法继续取球，则游戏结束。
此时，持有奇数个球的一方获胜。
如果两人都是奇数，则为平局。

假设双方都采用最聪明的取法，
第一个取球的人一定能赢吗？
试编程解决这个问题。

输入格式：
第一行3个正整数n1 n2 n3，空格分开，表示每次可取的数目 (0<n1,n2,n3<100)
第二行5个正整数x1 x2 … x5，空格分开，表示5局的初始球数(0<xi<1000)

输出格式：
一行5个字符，空格分开。分别表示每局先取球的人能否获胜。
能获胜则输出+，
次之，如有办法逼平对手，输出0，
无论如何都会输，则输出-

例如，输入：
1 2 3
1 2 3 4 5

程序应该输出：

0 + 0 -

再例如，输入：
1 4 5
10 11 12 13 15

程序应该输出：
0 - 0 + +

再例如，输入：
2 3 5
7 8 9 10 11

程序应该输出：

0 0 0 0

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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
分析：
博弈论
用数组a记录下每次可取的数目，总共三个
最后是根据两个人手中持球数目的奇偶性来判断输赢
每局的初始球数最多为1000
可以声明一个char类型三维数组cache来记录总球数为n的情况下两人最终的结果
为什么为三维数组来记录呢？
因为最后判断的是两个人手中球数的奇偶性，而不需要具体数值，可以在此处用记忆型递归。0表示此时手中为偶数，1表示为奇数
这里用记忆型递归可以优化程序，因为如果不用记忆型递归，会重复计算很多相同的情况。用0 1来代替具体的数字
总共要进行五局博弈
所以可以对每一局的博弈来dfs，每次可以取的球数为a[0] a[1] a[2]
对于每一局的博弈，如果出现了先取球的人能获胜的情况，就可以直接结束dfs 直接返回+
若dfs过程中，遇到了平局的情况，那么先记录下来有平局这种情况，如果dfs遍历结束后，没有胜利的情况，则返回平局，若平局也没有，则返回输
题上说两人每次都采取最佳取法，那么在递归时要注意：
dfs(int n,int me,int you){
char res=dfs(n-a[i], you, (a[i]&1)==0?me:1-me);
}
第一个人取完之后，要换对手取，所以递归时，me 跟you要调换位置，因为对手也要取最佳的策略。

static int[] a=new int[3];static char[][][] cache=new char[1000][2][2];    public static void main(String[] args) {Scanner sc=new Scanner(System.in);int[] b=new int[5];for(int i=0;i<1000;i++) {for(int j=0;j<2;j++) {for(int k=0;k<2;k++) {cache[i][j][k]=' ';}}}for(int i=0;i<3;i++) {a[i]=sc.nextInt();}Arrays.sort(a);for(int j=0;j<5;j++) {int sum=sc.nextInt();char res=dfs(sum,0,0);System.out.print(res+" ");        }       }static char dfs(int n,int me,int you) {if(n<a[0]) {if((me&1)==1&&(you&1)==0)  //如果我手里是奇数，对手是偶数，返回+return '+';else if((me&1)==0&&(you&1)==1)//我是偶数，对手奇数 返回-return '-';else return'0';           //否则就为平局}if(cache[n][me][you]!=' ')return cache[n][me][you];//记忆型递归boolean ping=false;for(int i=0;i<3;i++) {if(n>=a[i]) {/*** 如果a[i]为偶数，就把me设置为0 为奇数就设置为1,调用dfs时，me 跟you都是0* 此处直接用01表示meyou 是偶数还是奇数，因为最后判断的是me跟you的* 奇偶性，而不需要me you 的具体数值， 可以在此处用记忆型递归* */char res=dfs(n-a[i], you, (a[i]&1)==0?me:1-me);if(res=='-') {//res进行dfs时，将我与对手调换了位置cache[n][me][you]='+';//所以对手输时，我赢return'+';  //如果存在我赢的情况，直接返回我赢}if(res=='0') {  //如果存在平局，先记录下来ping=true;}      }}   if(ping) {  //如果程序运行到这一步，那么说明不存在我赢的情况，所以如果有平局，就返回0cache[n][me][you]='0';return'0';}else {  //如果不存在平局，就返回- cache[n][me][you]='-';return'-';}}

第十题：压缩变换

小明最近在研究压缩算法。
他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。
然而，要使数值很小是一个挑战。

最近，小明需要压缩一些正整数的序列，这些序列的特点是，后面出现的数字很大可能是刚出现过不久的数字。对于这种特殊的序列，小明准备对序列做一个变换来减小数字的值。

变换的过程如下：
从左到右枚举序列，每枚举到一个数字，如果这个数字没有出现过，刚将数字变换成它的相反数，如果数字出现过，则看它在原序列中最后的一次出现后面（且在当前数前面）出现了几种数字，用这个种类数替换原来的数字。

比如，序列(a1, a2, a3, a4, a5)=(1, 2, 2, 1, 2)在变换过程为：
a1: 1未出现过，所以a1变为-1；
a2: 2未出现过，所以a2变为-2；
a3: 2出现过，最后一次为原序列的a2，在a2后、a3前有0种数字，所以a3变为0；
a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字，所以a4变为1；
a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。
现在，给出原序列，请问，按这种变换规则变换后的序列是什么。

输入格式：
输入第一行包含一个整数n，表示序列的长度。
第二行包含n个正整数，表示输入序列。

输出格式：
输出一行，包含n个数，表示变换后的序列。

例如，输入：
5
1 2 2 1 2

程序应该输出：
-1 -2 0 1 1

再例如，输入：
12
1 1 2 3 2 3 1 2 2 2 3 1

程序应该输出：
-1 0 -2 -3 1 1 2 2 0 0 2 2

数据规模与约定
对于30%的数据，n<=1000；
对于50%的数据，n<=30000；
对于100%的数据，1 <=n<=100000，1<=ai<=10^9

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

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

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

分析：
两种方案，第一种只能跑一部分的分，对于数据较大的情况下会超时，第二种能跑全部的分。下面分别介绍两种方案。

第一种方案(未优化)：
声明两个数组，一个用来存放输入的原始数据，一个用来存放变换后的结果。用map来记录当前输入的数据最后一次出现的位置，这里的最后一次出现位置是指当前输入的数据，并不是已经输入完成的数据。
对于当前输入的数据，分两种情况讨论：
1.之前没出现过，那么可以直接将此数据存入到结果数组的相应位置
2.之前出现过，那么就用map来获取到第一次出现的位置，然后遍历第一次出现的位置到当前输入数据的位置中间的数据有多少种，在遍历时可以声明一个set集合来存放不同的数据，最后获取set集合的长度即为两个位置中间的数据种数。将整个数据种数赋值给结果数组相应位置即可。

static Map<Integer,Integer> map=new HashMap<Integer, Integer>();static int[] data; //记录原始数据static int[] ans;  //记录答案public static void main(String[] args) {Scanner sc=new Scanner(System.in);int n=sc.nextInt();data=new int[n];ans=new int[n];for(int i=0;i<n;i++) {int sum=sc.nextInt();data[i]=sum;if(map.get(sum)==null) { //如果这个数据之前没出现过，那么在输出时就变为-sumans[i]=-sum;}else {//考虑出现过的情况Set<Integer> set=new HashSet<Integer>();for(int j=map.get(sum)+1;j<i;j++) {//set集合是存不相同的数据,//用set来记录两个此数字与第一次出现的位置中间由多少种数set.add(data[j]);}ans[i]=set.size();//更新答案数组}map.put(sum, i);//记录sum最后一次出现的位置} for(int i=0;i<n;i++) {System.out.print(ans[i]+" ");}}

第二种方案（已优化）：
用区间树来存储两个位置中间的数据种数，只需把区间树构建好即可，这样在查询两个位置中间有多少种数据时，就不用再从新遍历中间的数据，可以直接从区间树来获取相应的值。

static Map<Integer,Integer> map=new HashMap<Integer, Integer>();static int[] a; //记录原始数据static int[] ans;  //记录答案static int[] b;    //这是一个01序列 如果b[p]的位置为1 则表示a[p]这个数字//最后一次出现的位置是p,而a[p]这个值曾经出现的位置上//都为0private static int n;private static SegTree root;public static void main(String[] args) {Scanner sc=new Scanner(System.in);n=sc.nextInt();a=new int[n];ans=new int[n];b=new int[n];root=buildSegTree(0, n-1);for(int i=0;i<n;i++) {int sum=sc.nextInt();a[i]=sum;Integer preIndex=map.get(sum);if(preIndex==null) {ans[i]=-sum;b[i]=1;update(root, i, 1);}else {ans[i]=query(root,preIndex+1,i-1);//统计两个位置之间的1的个数-->求区间和b[preIndex]=0;b[i]=1;update(root, preIndex, -1);update(root, i, 1);}map.put(sum, i);}    for(int i=0;i<n;i++) {System.out.print(ans[i]+" ");}}private static int query(SegTree tree,int x, int y) {int l=tree.l;int r=tree.r;if(x<=l && y>=r)return tree.sum;int mid=(l+r)/2;int ans=0;if(x<=mid)ans+=query(tree.lson, x, y);if(y>mid)ans+=query(tree.rson, x, y);      return ans;}//构建线段树private static SegTree buildSegTree(int l,int r) {SegTree segTree=new SegTree(l,r);     if(l==r) {segTree.sum=b[l];return segTree;}int mid=(l+r)/2;SegTree lson=buildSegTree(l, mid);SegTree rson=buildSegTree(mid+1, r);segTree.lson=lson;segTree.rson=rson;segTree.sum=lson.sum+rson.sum;return segTree;  }static void update(SegTree tree,int p,int i) {if(tree==null)return;//更新根结点的sumtree.sum+=i;int l=tree.l;int r=tree.r;int mid=(l+r)>>1;if(p<=mid) {update(tree.lson, p, i);}else{update(tree.rson, p, i);          }       } static class SegTree {int l,r; //所有区间int sum; //区间和SegTree lson; //左子树SegTree rson; //右子树public SegTree(int l,int r){this.l=l;this.r=r;     }}