2015年第六届蓝桥杯JavaA组
第1题：熊怪吃核桃
森林里有一只熊怪，很爱吃核桃。不过它有个习惯，每次都把找到的核桃分成相等的两份，吃掉一份，留一份。如果不能等分，熊怪就会扔掉一个核桃再分。第二天再继续这个过程，直到最后剩一个核桃了，直接丢掉。
有一天，熊怪发现了1543个核桃，请问，它在吃这些核桃的过程中，一共要丢掉多少个核桃。
请填写该数字（一个整数），不要填写任何多余的内容或说明文字。
——————————————————————————————————————————————————————
public class Main {
public static void main(String[] args) {
int ans = 0;
for(int i = 1543;i > 0;) {
if((i & 1) == 0) {//偶数
i /= 2;
}else {
ans++;
i = (i - 1) / 2;
}
}
System.out.println(ans);
}
}
第2题：星系炸弹
在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。
每个炸弹都可以设定多少天之后爆炸。
比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。
有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。
请填写该日期，格式为 yyyy-mm-dd 即4位年份2位月份2位日期。比如：2015-02-19
请严格按照格式书写。不能出现其它文字或符号。
import java.util.Calendar;
public class Main {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
c.set(2014, 10, 9);
c.add(Calendar.DATE, 1000);
System.out.println(c.getTime().toLocaleString());
}
}
第3题：九数分三组
1~9的数字可以组成3个3位数，设为：A,B,C, 现在要求满足如下关系：
B = 2 * A
C = 3 * A
请你写出A的所有可能答案，数字间用空格分开，数字按升序排列。
注意：只提交A的值，严格按照格式要求输出。
public class Main {
static int[] arr = {1,2,3,4,5,6,7,8,9};
//全排列
public static void main(String[] args) {
f(0);
}
private static void f(int k) {
if(k == 9) {
int a = arr[0] * 100 + arr[1] * 10 + arr[2];
int b = arr[3] * 100 + arr[4] * 10 + arr[5];
int c = arr[6] * 100 + arr[7] * 10 + arr[8];
if(b == 2 * a && c == 3 * a) System.out.print(a + " ");
}
for(int i = k;i < 9;i++) {
int tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
f(k + 1);
tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
}
}
}
第4题：循环节长度
两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153… 其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。
请仔细阅读代码，并填写划线部分缺少的代码。
public static int f(int n, int m)
{
n = n % m;
Vector v = new Vector();
for(;;)
{
v.add(n);
n *= 10;
n = n % m;
if(n==0) return 0;
if(v.indexOf(n)>=0) ____return v.size() - v.indexOf(n) ___ ; //填空
}
}
注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。
——————————————————————————————————————————————————
用例子去IDE，DEBUG一下，把那一行注释掉运行发现是死循环，所以那一行肯定是要有 return 的，一步步调试发现， n 代表 每一个小数位上的数值 。v 会 add n ，然后，在那一行检查 n 是否已经在 v 出现过了，若出现过，说明循环节找到了
第5题：
打印菱形
给出菱形的边长，在控制台上打印出一个菱形来。
为了便于比对空格，我们把空格用句点代替。
当边长为8时，菱形为：
下面的程序实现了这个功能，但想法有点奇怪。
请仔细分析代码，并填写划线部分缺失的代码。
public class A
{
public static void f(int n)
{
String s = "*";
for(int i=0; i<2*n-3; i++) s += ".";
s += "*";
String s1 = s + "\n";
String s2 = "";
for(int i=0; i"+s);
s = "." + ____s.substring(0, s.length() - 3)______ + "*"; //填空
s1 = s + "\n" + s1;
s2 += s + "\n";
}
System.out.println(s1+s2);
}
public static void main(String[] args)
{
f(8);
}
}
注意，只能填写缺少的部分，不要重复抄写已有代码。不要填写任何多余的文字。
————————————————————————————————————————————————————
思路：初始的 s 是最中间的那一行，然后每一行都是由上一行截取一部分，再拼接 . 和 * 得到的
第6题：加法变乘法
我们都知道：1+2+3+ … + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
比如：
1+2+3+…+10 * 11+12+…+27 * 28+29+…+49 = 2015
就是符合要求的答案。
请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。
注意：需要你提交的是一个整数，不要填写任何多余的内容。
——————————————————————————————————————————————————————
public class Main {
public static void main(String[] args) {
//枚举两个 * 的位置
for(int i = 1;i <= 46;i++) { //第一个 * 左边的数字
for(int j = i + 2;j <= 48;j++) {//第二个 * 左边的数字
//只比较变动的两处产生的差值
if(i * (i + 1) - (i + (i + 1)) + j * (j + 1) - (j + (j + 1)) == 2015 - 1225)
System.out.println(i + " " + j);
}
}
}
}
第7题：牌型种数
小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
请填写该整数，不要填写任何多余的内容或说明文字。
——————————————————————————————————————————————————
因为不考虑花色，所以这 52 张牌中只有 13 种点数的牌，每人抓 13 次，就是 13 次递归，可以理解为 有 13 个格子，编号 1–13，每个格子编号对应相同点数的牌型，每种牌型都可能抓 0—4 张这五种情况，所以规模是 513。
| 牌的点数(也是格子编号) | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 抓到该牌型的数量 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 | 0/1/2/3/4 |
对于这种情况：1,2,3,4 点数的牌每种都抓了 4 张，已经超过了 13 张，就没必要继续递归，所以需要剪枝。
public class Main {
static int ans;//3598180
public static void main(String[] args) {
f(0, 0);
System.out.println(ans);
}
/**
* @param k 目前考虑到点数为 k 的牌型
* @param count 手中已有的牌的总数
*/
private static void f(int k, int count) {
if(count > 13 || k > 13) return ;//剪枝
if(k == 13 && count == 13) {
ans++;
return ;
}
for(int i = 0;i < 5;i++) {//点数为 k 的牌型，都可能抓 0---4张
f(k + 1, count + i);
}
}
}
第8题：移动距离
X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3…
当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …
我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）
输入为3个整数w m n，空格分开，都在1到10000范围内
w为排号宽度，m,n为待计算的楼号。
要求输出一个整数，表示m n 两楼间最短移动距离。
例如：
用户输入：
6 8 2
则，程序应该输出：
4
再例如：
用户输入：
4 7 20
则，程序应该输出：
5
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
————————————————————————————————————————————————————
就是求两个点的曼哈顿距离
可以看出来，编号是按照 S 型排列布置的，奇数行是编号从左到右（最右侧是最大值），偶数行是编号从右到左（最左侧是最大值），行列都从 1 开始
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int w = sc.nextInt();
int m = sc.nextInt();
int n = sc.nextInt();
sc.close();
int rm = m % w == 0 ? m / w : m / w + 1; //m 的row
int rn = n % w == 0 ? n / w : n / w + 1; //n 的row
int cm = 0;// m 的col
int cn = 0;// n 的col
if(rm % 2 == 0) {//偶数行
cm = rm * w - m + 1;//rm * w 是 m 所在行的最大值
}else {
cm = w - (rm * w - m);
}
if(rn % 2 == 0) {//偶数行
cn = rn * w - n + 1;
}else {
cn = w - (rn * w - n);
}
System.out.println(Math.abs(rm - rn) + Math.abs(cm - cn));
}
}
第9题：垒骰子
赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 10^9 + 7 的结果。
不要小看了 atm 的骰子数量哦～
「输入格式」
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 不能紧贴在一起。
「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。
「样例输入」
2 1
1 2
「样例输出」
544
「数据范围」
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。
————————————————————————————————————————————————————
递归版：（能得30分）
import java.util.Scanner;
public class Main {
static final int MOD = 1000000007;
static int[] op = new int[7]; //op[i]表示 i 的 对面是 op[i]
static boolean[][] conflict = new boolean[7][7];
static int m;
static int n;
public static void main(String[] args) {
//初始化op数组
op[1] = 4;
op[4] = 1;
op[2] = 5;
op[5] = 2;
op[3] = 6;
op[6] = 3;
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
for(int i = 0;i < m;i++) {
int x = sc.nextInt();//冲突对
int y = sc.nextInt();
conflict[x][y] = true;
conflict[y][x] = true;
}
sc.close();
long ans = 0;
for(int up = 1; up <= 6;up++) {//第一层的骰子"上"面的数字，六种可能
ans = (ans + 4 * f(up, n - 1)) % MOD;//每一层都可以转出四种方案
}
System.out.println(ans);
}
/**
* 上一层定好了朝上的数字为up的情况下，垒好count个骰子的方案数
* @param up 上一层骰子"上"面的数字
* @param count
* @return
*/
private static long f(int up, int count) {
//前面 n 个骰子定好了，这是1种方案，但是四周的面可以转动，"前"面可以有4种选择，所以是四种方案
if(count == 0) return 4;
long ans = 0;
for(int upp = 1;upp <= 6;upp++) {
//上一层骰子的"下"面 和 这一层骰子的"上"面冲突的话
if(conflict[op[up]][upp]) continue;
ans = (ans + f(upp, count - 1)) % MOD;
}
return ans;
}
}
动规版：（依然不能满分）
考虑从最下层开始，有六种放法。
import java.util.Scanner;
public class Main {
static final int MOD = 1000000007;
static int[] op = new int[7]; //op[i]表示 i 的 对面是 op[i]
static boolean[][] conflict = new boolean[7][7];
static int m;
static int n;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
for(int i = 0;i < m;i++) {
int x = sc.nextInt();//冲突对
int y = sc.nextInt();
conflict[x][y] = true;
conflict[y][x] = true;
}
sc.close();
long[][] dp = new long[2][7];//每一层只与上一层有关，所以两层就够了
//初始化dp
for(int j = 1;j <= 6;j++) dp[0][j] = 1;
int cur = 0;//当前行
//迭代层数
for(int level = 2;level <= n;level++) {
cur = 1 - cur;
//尝试"上"面的数字
for(int j = 1;j <= 6;j++) {
dp[cur][j] = 0;
//将与 op[j]不冲突的上一层格子的里面的数累加起来
for(int i = 1;i <= 6;i++) {
if(conflict[op[j]][i]) continue;//冲突的面朝上是不可取的
dp[cur][j] = (dp[cur][j] + dp[1 - cur][i]) % MOD;
}
}
}
long sum = 0;
//求最终答案，即第 n 层的总和
for(int k = 1;k <= 6;k++) {
sum = (sum + dp[cur][k]) % MOD;
}
//每一层都可旋转处四种方案，所以还要乘以4^n
long ans = 1;
long tmp = 4;
long p = n;
//快速幂求 4^n
while(p != 0) {
if((p & 1) == 1) ans = (ans * tmp) % MOD;
tmp = (tmp * tmp) % MOD;
p >>= 1;
}
System.out.println((ans * sum) % MOD);
}
}
这个结果不对，看着C++敲得，不知道哪里敲错了。。。
最终版：矩阵乘法
继续优化，上面迭代层数那里是三重循环，考虑到 n 可能很大，所以无法满分
能力有限，以后再看。。