【2017年蓝桥杯Java-B组省赛题解】
2017Java-B组省赛
-
-
- 一、购物单（计算器）
- 二、纸牌三角形（模拟、数学思维去重）
- 三、承压计算（杨辉三角、数学思维）
- 四、魔方状态（做不来）
- 五、六、程序填空题
- 七、日期问题（非常细节的模拟、Calendar类）
- 八、包子凑数（最大公约数）
- 九、分巧克力（模拟、二分）
- ※十、k倍区间（前缀和）
-
一、购物单（计算器）
标题： 购物单
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。
小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。
取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
-----------------
**** 180.90 88折
**** 10.25 65折
**** 56.14 9折
**** 104.65 9折
**** 100.30 88折
**** 297.15 半价
**** 26.75 65折
**** 130.62 半价
**** 240.28 58折
**** 270.62 8折
**** 115.87 88折
**** 247.34 95折
**** 73.21 9折
**** 101.00 半价
**** 79.54 半价
**** 278.44 7折
**** 199.26 半价
**** 12.97 9折
**** 166.30 78折
**** 125.50 58折
**** 84.98 9折
**** 113.35 68折
**** 166.57 半价
**** 42.56 9折
**** 81.90 95折
**** 131.78 8折
**** 255.89 78折
**** 109.17 9折
**** 146.69 68折
**** 139.33 65折
**** 141.16 78折
**** 154.74 8折
**** 59.42 8折
**** 85.44 68折
**** 293.70 88折
**** 261.79 65折
**** 11.30 88折
**** 268.27 58折
**** 128.29 88折
**** 251.03 8折
**** 208.39 75折
**** 128.88 75折
**** 62.06 9折
**** 225.87 75折
**** 12.89 75折
**** 34.28 75折
**** 62.16 58折
**** 129.12 半价
**** 218.37 半价
**** 289.69 8折
--------------------
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。
请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。
特别提醒：不许携带计算器入场，也不能打开手机。
用电脑自带计算器计算就行，注意取款机只能取100的倍数。
答案：5200
二、纸牌三角形（模拟、数学思维去重）
标题：纸牌三角形
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。
A
9 6
4 8
3 7 5 2
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
import java.util.*;
public class Main {
static LinkedList<Integer> tmp = new LinkedList<>();
static int ans = 0;
static int[] vis = new int[10];
public static void main(String[] args) {
dfs();
System.out.println(ans / 6);
}
static void dfs() {
if (tmp.size() == 9) {
if (tmp.get(0) + tmp.get(1) + tmp.get(2) + tmp.get(3) ==
tmp.get(3) + tmp.get(4) + tmp.get(5) + tmp.get(6) && tmp.get(3) + tmp.get(4) + tmp.get(5) + tmp.get(6) ==
tmp.get(6) + tmp.get(7) + tmp.get(8) + tmp.get(0)) {
System.out.println(tmp);
ans++;
}
return;
}
for (int i = 1; i <= 9; i++) {
if (vis[i] == 1) {
continue;
}
vis[i] = 1;
tmp.add(i);
dfs();
vis[i] = 0;
tmp.removeLast();
}
}
}
题目中已知，镜像、旋转属于同一种，旋转有三种情况，由旋转之后的镜像又有三种，所以同一个等边三角形会被计算6次，但实际有效的是1次，所以用全排列求得结果还要 / 6。
答案：144
三、承压计算（杨辉三角、数学思维）
标题：承压计算
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：2086458231
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。
对于某一层 i，它这一层有 i 个数字，当 j = 1时：weight[i][j] += weight[i - 1][j] / 2；当 j = i 时：weight[i][j] += weight[i - 1][j - 1] / 2（就是在每一层的左右两边的情况）。其余处于中间的情况，weight[i][j] = weight[i][j] + ( weight[i - 1][j - 1] + weight[i - 1][j] ) / 2。这样一直迭代到第30层，注意，题目中说的计量单位很小，我们不知道计量单位，只能通过迭代的结果中的最小值，用最小示数 / 最小值，来确定计量单位。再找到最大值，用计量单位 * 最大值即得到最后答案。
package Chapter_5;
import java.util.*;
/*
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
*/
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
double[][] arr = new double[30][30];
for (int i = 0; i < 29; i++) {
for (int j = 0; j <= i; j++) {
arr[i][j] = scan.nextDouble();
}
}
// 开始推导
for (int i = 1; i < 30; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0) {
arr[i][j] += arr[i - 1][j] / 2;
} else if (j == i) {
arr[i][j] += arr[i - 1][j - 1] / 2;
} else {
arr[i][j] += (arr[i - 1][j - 1] + arr[i - 1][j]) / 2;
}
}
}
double min = arr[29][0];
double max = arr[29][0];
for (int i = 0; i < 30; i++) {
if (arr[29][i] < min) {
min = arr[29][i];
}
if (arr[29][i] > max) {
max = arr[29][i];
}
}
System.out.println(max * (2086458231 / min));
// 7.2665192664E10
}
}
答案：72665192664
四、魔方状态（做不来）
标题：魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
这道题过于困难…不适合我，比赛的时候应该不会花时间去做。
补充一道2017年javaA组的第一题：
标题：迷宫
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
------------
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
------------
请你计算一下，最后，有多少玩家会走出迷宫?
而不是在里边兜圈子。
请提交该整数，表示走出迷宫的玩家数目，不要填写任何多余的内容。
如果你还没明白游戏规则，可以参看一个简化的4x4迷宫的解说图：
p1.png
直接DFS搜索，注意不需要回溯，出去了就ans++。
import java.util.*;
public class Main {
static char[][] map = new char[11][11];
static int[][] vis = new int[11][11];
static LinkedList<Character> tmp = new LinkedList<>();
static int ans = 0;
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
for (int i = 0; i < 10; i++) {
map[i] = scan.next().toCharArray();
System.out.println(map[i]);
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
vis = new int[11][11];
tmp = new LinkedList<>();
tmp.add(map[i][j]);
dfs(map[i][j], i, j);
}
}
System.out.println(ans);
}
static void dfs(char next, int i, int j) {
int tmpx;
int tmpy;
if (next == 'D') {
tmpx = i + 1;
tmpy = j;
} else if (next == 'U') {
tmpx = i - 1;
tmpy = j;
} else if (next == 'L') {
tmpx = i;
tmpy = j - 1;
} else {
tmpx = i;
tmpy = j + 1;
}
if (tmpx < 0 || tmpy < 0 || tmpx >= 10 || tmpy >= 10) {
ans++;
System.out.println("*****");
System.out.println(tmp);
return;
}
if (vis[tmpx][tmpy] == 1) {
System.out.println("=====");
System.out.println(tmp);
return;
}
vis[tmpx][tmpy] = 1;
tmp.add(map[tmpx][tmpy]);
dfs(map[tmpx][tmpy], tmpx, tmpy);
}
}
答案：31
还是这种小题目适合我 x）。
五、六、程序填空题
七、日期问题（非常细节的模拟、Calendar类）
这道题的题目描述，到处都是关键点，首先告诉只有三种情况：年月日、月日年、日月年，又告诉答案必须要从早到晚排序，注意输入格式、输出格式里面的“----”不是要输入、输出的东西！！
这道题涉及到某年某月的月份天数的确定，可以使用Calendar类实现，实现如下：
//生成Calendar对象
Calendar cal = Calendar.getInstance();
// 获取这个月到底有几天
cal.set(year_num, month, 0);
int monty_day = cal.get(Calendar.DATE);
注意月份从0开始，一月份应该传入0。如果日期为0，则自动跳转到上一个月的最后一天，例如：cal.set(2000, 2, 0)设置的是三月份的上一月份的最后一天，也就是2月份的最后一天，再用cal.get(Calendar.DATE)就可以得到上一个月的天数。
对于输入02/03/04，可以使用String的split进行分割，在遍历三种情况时，我们可以只修改读取的下标而不用修改遍历的代码。还需要注意答案要去重 + 排序，代码如下：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String[] imps = new String[];
String imp = scan.next();
imps = imp.split("/");
// 只有三种情况：年月日、月日年、日月年
// 年月日 012
// 月日年 201
// 日月年 210
int[][] num = new int[][] {{0,1,2},{2,0,1},{2,1,0}};
// 答案要去重
Set<String> ans_set = new HashSet<>();
List<String> ans_list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
String ans = "";
// 保证a一直拿到的都是年，b一直拿到的是月，c一直拿到的是日
String year = imps[num[i][0]];
String month = imps[num[i][1]];
String day = imps[num[i][2]];
int a = Integer.parseInt(year);
int b = Integer.parseInt(month);
int c = Integer.parseInt(day);
int year_num = 0;
if (a >= 60) {
ans = ans + "19" + year;
year_num = 1900 + a;
} else {
ans = ans + "20" + year;
year_num = 2000 + a;
}
if (b >= 1 && b <= 12) {
ans = ans + "-" + month;
} else {
continue;
}
Calendar cal = Calendar.getInstance();
// 获取这个月到底有几天
cal.set(year_num, b, 0);
int monty_day = cal.get(Calendar.DATE);
if (c >= 1 && c <= monty_day) {
ans = ans + "-" + day;
} else {
continue;
}
// 答案去重
if (ans_set.contains(ans)) {
continue;
} else {
ans_set.add(ans);
ans_list.add(ans);
}
}
// 从小到大排序日期
Collections.sort(ans_list);
for (int i = 0; i < ans_list.size(); i++) {
System.out.println(ans_list.get(i));
}
}
}
八、包子凑数（最大公约数）
首先考虑只有一个包子，那么如果个数是1，那么都可以凑出来，不是1，那都凑不出来的数=INF。回归到本质，这道题其实是让找几个数的gcd，如果gcd = 1则不可凑出的数是有限个（可以用dp数组找），如果gcd != 1，说明这些数都是某个数的倍数，被拿来拿去相加，也还是某个数的倍数，始终有数凑不出来，所以也是INF。
import java.util.*;
public class Main {
static int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
// 有多少数目的包子是凑不出来的
int[] bz = new int[n];
int flag = 0;
boolean[] dp = new boolean[10001];
dp[0] = true;
for (int i = 0; i < n; i++) {
bz[i] = scan.nextInt();
dp[bz[i]] = true;
}
if (n == 1 && bz[0] != 1) {
System.out.println("INF");
} else if (n == 1 && bz[0] == 1) {
System.out.println(0);
} else {
int tmp = bz[0];
for (int i = 1; i < n; i++) {
tmp = gcd(tmp, bz[i]);
}
// 最大公约数为 1 那么都可以凑出来
if (tmp == 1) {
flag = 1;
}
// 如果最大公约数不是 1，说明所有能够凑成的数都是某个数的倍数，INF
if (flag == 0) {
System.out.println("INF");
} else {
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 10000; j++) {
if (dp[j]) {
continue;
}
if (bz[i] <= j) {
dp[j] = dp[j - bz[i]];
}
}
}
for (int i = 1; i <= 10000; i++) {
if (dp[i]) {
continue;
}
ans++;
}
System.out.println(ans);
}
}
}
}
九、分巧克力（模拟、二分）
模拟分巧克力的过程，一块巧克力能够分成的正方形数目 = (h / a) * (w / a)，a是每块巧克力的边长，我们要保证正方形数目 >= k的情况下，a最大，本质是遍历1 - max所有的可能边长，遇到这种遍历找满足某种条件的值时，很容易就能想到用二分来加速。
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int k = scan.nextInt();
int[] h = new int[n];
int[] w = new int[n];
int max = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
h[i] = scan.nextInt();
w[i] = scan.nextInt();
if (h[i] > max) {
max = h[i];
}
if (w[i] > max) {
max = w[i];
}
}
int left = 1;
int right = max;
int mid;
int ans = 0;
while (left <= right) {
mid = left + (right - left) / 2;
int cnt = 0;
for (int i = 0; i < n; i++) {
cnt += (h[i] / mid) * (w[i] / mid);
}
if (cnt >= k) {
if (mid > ans) {
ans = mid;
}
left = mid + 1;
} else {
right = mid - 1;
}
}
System.out.println(ans);
}
}
※十、k倍区间（前缀和）
需要用到前缀和，外加一些加速技巧（等价转换），单纯的前缀和会超时。
前缀和数组：preSum[i] = A0 + … + Ai-1
i - j的区间和 = preSum[j + 1] - preSum[i] = Ai + … + A[j]
(preSum[j + 1] - preSum[i]) % k == 0 等价于：preSum[j + 1] % k == preSum[i] % k ，我们只要统计preSum[i + 1] % k相同的个数。
注意，这里忽略了单独一个前缀和能被 k 整除的情况，所以在最后还要统计加回来。换句话说，这里只探讨两个前缀和构成的区间和的情况，没有考虑一个前缀和（从0到自身）的和的情况。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int k = scan.nextInt();
int[] num = new int[n];
long ans = 0;
for (int i = 0; i < n; i++) {
num[i] = scan.nextInt();
}
// preSum[i] = A0 + ... + Ai-1
// i - j的区间和 = preSum[j + 1] - preSum[i] = Ai + ... + A[j]
// (preSum[j + 1] - preSum[i]) % k == 0
// 所以，preSum[j + 1] % k == preSum[i] % k
// 前缀和数组
int[] preSum = new int[n + 1];
for (int i = 1; i < n + 1; i++) {
preSum[i] = (preSum[i - 1] + num[i - 1]) % k;
}
long[] cnt = new long[n + 1];
// 只需要统计preSum % k相同的个数即可
for (int i = 1; i < n + 1; i++) {
ans += cnt[preSum[i]];
cnt[preSum[i]]++;
}
// 前面找的都是preSum[i] % k == preSum[j] % k的情况
// 没有单独考虑前缀和的情况
// 别忘了有前缀和直接能被k整除的情况
System.out.println(ans + cnt[0]);
// 也可以通过将cnt[0]初值赋为1来保证获取所有的区间可能
}
}
2017年的蓝桥杯，在填空题方面有难度，但编程题难度较小，都是可以拿分的，但是一开始做填空题一定要稳住心态，你难我难都难。