蓝桥杯2017-Java B组省赛真题
前言
本文章只包含题目+答案，没有详细的分析过程（仅为了个人的归纳复盘使用）
题目以及讲解是看B站的视频：https://www.bilibili.com/video/BV1GE411F7Pj?p=476&vd_source=9d88d1508341bdfe8c5c3dccba168d9b
2017-Java省赛第一题——购物单
数据：
**** 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折
答案：5200
关于这题的tips：
不能使用自带的计算器，那就使用excel最快，（其实用电脑计算器一个一个算也可以，但是很费事），直接copy，然后将文字转为列。
接下来就是将几几折变成小数，算一个折后的价钱，直接往下拖就能得到所有的折后价了，再求和就行了。（突然变成计算机二级考试？其实我没有上过office课，也没考过计算机等级考试[说来可笑，我是大数据专业，学得很杂，但是很多基础课程根本不上，比如是C语言......]）最后是5136.8595-->5200
其实这题用编程也可以实现，输入数据，然后做循环，一个一个求折后价再sum就行了
2017-Java省赛第二题——纸牌三角形
//纸牌三角形_全排列
public class Main02 {
static int[] a = {1,2,3,4,5,6,7,8,9};
static int ans;
static void f(int k){
if(k==9){
int x1 = a[0] + a[1] + a[3] + a[5];
int x2 = a[0] + a[2] + a[4] + a[8];
int x3 = a[5] + a[6] + a[7] + a[8];
if(x1 == x2&&x2 == x3) ans++;
}
for (int i = k; i < 9; i++) {
int t = a[k];
a[k] = a[i];
a[i] = t;
f(k+1);
t = a[k];
a[k] = a[i];
a[i] = t;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
f(0);
//结果要除以6，因为旋转和镜像算同一种，所以会有6个重复的算成一种
System.out.println(ans/6);
}
}
答案：144
关于这题的tips：
OK，开局一个全排列，有敲过前几年的真题的朋友对全排列的模板都已经熟的不能再熟了吧，套模板，写条件，一气呵成，over。（ 记得结果要除以6哈，原因上面解释过了）
2017-Java省赛第三题——承压计算
数据如下：
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 x x x 
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。
import java.util.Arrays;
import java.util.Scanner;
//承压计算
public class Main {
static long[][] arr = new long[30][30];
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
long facter = 1;//2的30次方
for (int i = 0; i < 30; i++) {
facter<<=1;//将factor向左移一位
}
//输入数据放入二维数组
for (int i = 0; i < 29; i++) {
for (int j = 0; j <= i; j++) {
long a = sc.nextLong();
arr[i][j] = a*facter;//每个数据都乘以factor来扩大它的计量倍数
}
}
//自上而下处理a[i][j]*factor(2的30次方)-->除以2，计入a[i+1][j]和a[i+1][j+1]
//循环处理第0~28行,最后一行是29行
for (int i = 0; i < 29; i++) {
for (int j = 0; j <=i; j++) {
long ha = arr[i][j]/2;
arr[i+1][j] += ha;
arr[i+1][j+1] += ha;
}
}
//对a[n-1]这一行进行排序，查看最小值与factor之间的倍数关系，决定最大值是多少
Arrays.sort(arr[29]);
System.out.println(arr[29][0]);
System.out.println(arr[29][29]);
System.out.println(arr[29][29]/(arr[29][0]/2086458231));
}
}
输出：
4172916462
145330385328
72665192664答案:72665192664
关于这题的tips：
首先处理输入，传进二维数组，将每个数据都乘以factor来扩大它的计量倍数。然后自上而下处理a[i][j]*factor(2的30次方)-->除以2，计入a[i+1][j]和a[i+1][j+1]，循环处理第0~28行,最后对最后一行进行排序，输出最大最小值，把题目中的最小值和输出的最小值做对比找到倍数关系，再对输出的最大值进行处理得到答案。
做这题的时候，要注意的是单位不同的问题！
2017-Java省赛第四题——魔方状态（魔鬼题）
参考代码：
import java.util.HashSet;
import java.util.Set;
//魔方状态_宽搜_模拟状态转移_去重
public class Main {
static char[][] start = {"oybbgb".toCharArray(),
"oybbgb".toCharArray(),
"oygbbb".toCharArray(),
"bygbby".toCharArray(),
"bybbgy".toCharArray(),
"obbogb".toCharArray(),
"obgobb".toCharArray(),
"bbgoby".toCharArray()};
static char[][][] q = new char[2000000][8][6];
static HashSet all_state = new HashSet();
static int front, tail;
static String to_string(char[][] a) {
String ans = "";
for (int i = 0; i < 8; ++i) {
ans += new String(a[i]);
}
return ans;
}
private static void swap(char[] a, int i, int j) {
char t = a[i];
a[i] = a[j];
a[j] = t;
}
private static void swap(char[][] a, int i, int j) {
char[] t = a[i];
a[i] = a[j];
a[j] = t;
}
//上层的块的旋转，面的相对位置调换
static void ucell(char[] a) {
swap(a, 0, 2);
swap(a, 2, 5);
swap(a, 5, 4);
}
//上层顺时针旋转
static void u(char[][] s) {
ucell(s[0]);
ucell(s[1]);
ucell(s[2]);
ucell(s[3]);
// 块的相对位置调换
swap(s, 1, 0);
swap(s, 2, 1);
swap(s, 3, 2);
}
//右层旋转是面的位置变化
static void rcell(char[] a) {
swap(a, 1, 0);
swap(a, 0, 3);
swap(a, 3, 5);
}
static void r(char[][] s)//魔方右层顺时针转
{
rcell(s[1]);
rcell(s[2]);
rcell(s[6]);
rcell(s[5]);
// 块的位置变化
swap(s, 2, 1);
swap(s, 5, 1);
swap(s, 6, 5);
}
static void fcell(char[] a) {
swap(a, 2, 1);
swap(a, 1, 4);
swap(a, 4, 3);
}
static void f(char[][] s)//前面一层 顺时针转
{
fcell(s[0]);
fcell(s[1]);
fcell(s[4]);
fcell(s[5]);
swap(s, 1, 5);
swap(s, 0, 1);
swap(s, 4, 0);
}
static void uwhole(char[][] s)//整个魔方从顶部看 顺时针转 用于判重
{
u(s);//上层旋转
// 下层旋转
ucell(s[4]);
ucell(s[5]);
ucell(s[6]);
ucell(s[7]);
// 完成自旋后，块的位置变动
swap(s, 5, 4);
swap(s, 6, 5);
swap(s, 7, 6);
}
static void fwhole(char[][] s)//整个魔方从前面看 顺时针转 用于判重
{
f(s);
fcell(s[2]);
fcell(s[6]);
fcell(s[7]);
fcell(s[3]);
swap(s, 2, 6);
swap(s, 3, 2);
swap(s, 7, 3);
}
static void rwhole(char[][] s)//整个魔方从右边看 顺时针转 用于判重
{
r(s);
rcell(s[0]);
rcell(s[3]);
rcell(s[4]);
rcell(s[7]);
swap(s, 3, 7);
swap(s, 0, 3);
swap(s, 4, 0);
}
static boolean try_insert(char[][] s) {
char[][] k = new char[8][6];
memcpy(k, s);
for (int i = 0; i < 4; i++) {
fwhole(k);
for (int j = 0; j < 4; j++) {
uwhole(k);
for (int q = 0; q < 4; q++) {
rwhole(k);
if (all_state.contains(to_string(k))) {
return false;
}
}
}
}
all_state.add(to_string(k));
return true;
}
private static void memcpy(char[][] k, char[][] s) {
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 6; j++) {
k[i][j] = s[i][j];
}
}
}
static void solve() {
front = 0;
tail = 1;
all_state.add(to_string(start));
memcpy(q[front], start);//填充q[0]，相当于第一个状态入队列
while (front < tail) {
/*将其所有变形，尝试加入set中*/
memcpy(q[tail], q[front]);//拷贝到tail
u(q[tail]);//上层顺时针旋转
if (try_insert(q[tail])) {
tail++;//扩展队列
}
memcpy(q[tail], q[front]);//拷贝到tail
r(q[tail]);//右层顺时针旋转
if (try_insert(q[tail])) {
tail++;//扩展队列
}
memcpy(q[tail], q[front]);//拷贝到tail
f(q[tail]);//前顺时针旋转
if (try_insert(q[tail])) {
tail++;//扩展队列
}
front++;//弹出队首
// cout << front << " " << tail << endl;
}
System.out.println(front);
}
public static void main(String[] args) {
solve();
}
}
答案：229879
关于这题的tips：
视频中参考的是http://t.csdn.cn/ransc这个博主的代码，进行了改动，并且把C语言转化成Java了
但是视频并没有把代码展示完全，所以我又重新在网上搜索了这题，发现了一个Java的解法和视频中的解法差不多的博客：http://t.csdn.cn/3u4Ep，不过真的要吐槽一下这题真的很难，网上也很少有人解答，而这才第四题。（2017年的出题老师是受了什么刺激吗？？）
而且上面的代码应该是正确的，但是我运行eclipse的时候显示溢出了，所以如果有朋友知道这题的做法，也可以在评论区交流一下呀。
2017-Java省赛第五题——取数位
题目如下：
//取数位
public class Main {
static int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
static int f(int x,int k){
if(len(x)-k==0) return x%10;
return __________;//填空
}
public static void main(String[] args) {
int x = 23513;
System.out.println(len(x));
System.out.println(f(x,5));
}
}
补充完整后的代码：
//取数位
public class Main {
static int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
//取x的第k位数字
static int f(int x,int k){
if(len(x)-k==0) return x%10;
return f(x/10,k);//填空,消除低位，仍然是求第k位
}
public static void main(String[] args) {
int x = 23513;
System.out.println(len(x));
System.out.println(f(x,3));
}
}
答案：f(x/10,k)
关于这题的tips：
仔细观察，题目要我们取数位，调用len()方法求长度，直接用题目给的数据推算一下代码逻辑，假设取第3位数字，那么5-3！=0，return我们要写的地方，倘若len(x)==k，取余能取出最后一位的数字，也就是说我们的答案要让长度变小且再次循环，所以要进行递归，让长度变短可以用除法来实现，所以答案就出来了：f(x/10,k)。
2017-Java省赛第六题——最大公共子串
题目如下：
//最大公共子串
public class Main {
static int f(String s1,String s2){
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
int[][] a = new int[c1.length+1][c2.length+1];
int max = 0;
for (int i = 1; i < a.length; i++) {
for (int j = 1; j < a[i].length; j++) {
if(c1[i-1]==c2[j-1]){
a[i][j] = ________________;//填空
if(a[i][j]>max) max = a[i][j];
}
}
}
return max;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = f("abcdkkk","baabcdadabc");
System.out.println(n);
}
}
补充完整后的代码：
//最大公共字串_动态规划
public class Main {
static int f(String s1,String s2){
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
int[][] a = new int[c1.length+1][c2.length+1];
int max = 0;
for (int i = 1; i < a.length; i++) {
for (int j = 1; j < a[i].length; j++) {
if(c1[i-1]==c2[j-1]){
a[i][j] = a[i-1][j-1] + 1;//填空
if(a[i][j]>max) max = a[i][j];
}
}
}
return max;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n = f("abcdkkk","baabcdadabc");
System.out.println(n);
}
}
答案：a[i-1][j-1] + 1
关于这题的tips：
这题是要求最大的公共子串的长度，那么题目的代码把两个字符串转化成数组，然后构造了二维数组， 当(c1[i-1]==c2[j-1])应该做什么，当这个条件成立，那么就说明匹配上了，就应该把二维数组的对应格子加1 ，然后把a[i][j]中存的最大值输出出来，也就是最大公共子串长度了。
2017-Java省赛第七题——日期问题
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
//日期问题
public class Main {
//判断是不是闰年
static boolean isLeap(int year){
return (year%4==0 && year%100!=0)|| year%400==0;
}
static String f(int a,int b,int c){
if(a>=0 && a<=59) a+=2000;
else if(a>=60 && a<=99) a+=1900;
else return "";
if(b<1 || b>12) return "";
if(c<1 || c>31) return "";
boolean _isleap = isLeap(a);
switch (b) {//日期校验
case 2:
if(_isleap && c>29) return "";
if(!_isleap && c>28) return "";
break;
case 4:
if(c>30) return "";
break;
case 6:
if(c>30) return "";
break;
case 9:
if(c>30) return "";
break;
case 11:
if(c>30) return "";
break;
default:
break;
}
String _a = a + "",_b = b + "",_c = c + "";
if(_b.length() == 1) _b = "0"+_b;
if(_c.length() == 1) _c = "0"+_c;
return _a + "-" + _b + "-" + _c;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
String in = sc.nextLine();
int a = 0,b = 0,c = 0;
a = (in.charAt(0)-'0')*10 + (in.charAt(1)-'0');
b = (in.charAt(3)-'0')*10 + (in.charAt(4)-'0');
c = (in.charAt(6)-'0')*10 + (in.charAt(7)-'0');
String case1 = f(a,b,c);
String case2 = f(c,a,b);
String case3 = f(c,b,a);
/*TreeSet带去重和排序功能*/
Set ans = new TreeSet();
if(case1 != "") ans.add(case1);
if(case2 != "") ans.add(case2);
if(case3 != "") ans.add(case3);
for(String s:ans){
System.out.println(s);
}
}
}
关于这题的tips：
首先，先写main函数，传入数据，传进一个字符串中，将三个以“/”分割的部分变成3个数字，构造三种不同的表示方法，分别为String case1,case2,case3,写一个f()方法将结果传进去，最后不要忘记去重！！这里用TreeSet去重，并把空串去掉。
写完了主方法就来构造一下f()方法：将分割好的三个数字赋给int a,b,c，如果a是00-59，那么就是2000-2059，如果a是60-99，那么就是1960-1999，其他的数字不符合要求，返回空串。再来判断b和c，也就是月和日，月<1或>12 都返回空串，日<1或 c>31 都返回空串。这里进行判断的时候还要记得闰年和平年的2月是不一样的天数（所以还要写一个isLeap()方法）。用switch（b）来描述月份的各种情况，有30天的，也有31天的。最后就是要判断月和日的数字长度，如果是个位数，就要在前面加‘0’。
isLeap()方法：写一个boolean类型的方法，闰年是对4取余和对100取余都为0或者对400取余为0的数。
2017-Java省赛第八题——包子凑数
import java.util.Scanner;
//包子凑数
public class Main08 {
/*有解则系数互质，若不互质，则说明有无限多个常数导致方程无解
* 有多少个C解不出方程-->完全背包
*/
static int n,g;
static int[] a = new int[101];
static boolean[] f = new boolean[10000];
//求最大公约数
static int gcd(int a,int b){
if(b==0) return a;
return gcd(b,a%b);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
f[0] = true;
for (int i = 1; i <= n; i++) {
a[i] = sc.nextInt();
if(i==1) g = a[i];//初始化最大公约数
else g = gcd(a[i],g);
//完全背包的递推
for (int j = 0; j < 10000-a[i]; j++) {
if(f[j]) f[j+ a[i]] = true;
}
}
if(g!=1){
System.out.println("INF");
return;
}
//统计个数
int ans = 0;
for (int i = 0; i < 10000; i++) {
if(!f[i]){
ans++;
}
}
System.out.println(ans);
}
}
关于这题的tips：
有没有一种代码越短其实越难的感觉，这题主要是思路难想，利用最大公约数和递推的思路求解（要仔细研究一下代码）
2017-Java省赛第九题——分巧克力
import java.util.Scanner;
//分巧克力_二分枚举
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int n,k;
int[] h = new int[100000];//宽度
int[] w = new int[100000];//高度
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
for (int i = 0; i < n; i++) {
h[i] = sc.nextInt();
w[i] = sc.nextInt();
}
int r = 10001;
int l = 1;
int ans = 0;
while(l<=r){
int mid = (l+r)/2;
int cnt = 0;
//每块巧克力，都按照len来切割
for (int i = 0; i < n; i++) {
cnt += (h[i]/mid)*(w[i]/mid);
}
if(cnt>=k){
l = mid + 1;
ans = mid;
}else{
r = mid - 1;
}
}
System.out.println(ans);
}
}
关于这题的tips：
这题直接使用暴力求解循环遍历也是可以的，但是肯定没办法得满分，因为会超出时间限制。所以这里采用的是二分枚举法。（详细看代码）
2017-Java省赛第十题——k倍区间
暴力求解+前缀和：（我测过了，这样写是28分）
import java.util.Scanner;
//k倍区间_枚举优化_前缀和
public class Main {
static int n,k;
static int[] a;
static int[] s;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
a = new int[n+1];
s = new int[n+1];
s[0] = 0;
for (int i = 1; i <= n; i++) {
a[i] = sc.nextInt();
s[i] = s[i-1] +a[i];
}
long ans = 0;
//枚举i,j
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
//i,j之间的区间和=s[j]-s[j-1]
if((s[j]-s[i-1])%k==0)
ans++;
}
}
System.out.println(ans);
}
}
优化后：
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
//k倍区间_枚举优化_前缀和
public class Main {
static int n,k;
static int[] a;
static int[] s;
static Map cnt = new HashMap();//同余的个数统计
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
a = new int[n+1];
s = new int[n+1];
s[0] = 0;
cnt.put(0, 1l);
for (int i = 1; i <= n; i++) {
a[i] = sc.nextInt();
s[i] = (s[i-1] +a[i])%k;
if(cnt.get(s[i])==null){
cnt.put(s[i], 1l);
}else{
cnt.put(s[i], cnt.get(s[i])+1);
}
}
long ans = 0;
//枚举i,j
for (int i = 0; i 关于这题的tips：
简单的暴力求解是可以解决问题的，但是只能解决10的3次方左右的数据，因此需要优化，优化代码在上面了。
总结
程序填空题（填结果）
01： 购物单 简单计算excel
02：纸牌三角形 全排列+特殊去重
03：承压计算 数组注意计量单位，要精确就先放大2^30来做除法
04：魔方状态 模拟+去重(难，适当放弃)
程序填空题（填代码）
05：取数位 递归搞清楚参数的含义及参数变化的方向
06：最大公共子串 经典dp
编程题
07：日期问题 常规日期运算，细心,考虑闰年;字符串处理
08：包子凑数 扩展欧几里得＋完全背包问题(dp)
09：分巧克力 二分枚举
10：k倍区间 前缀和+组合数学
2017年前面有些题居然比后面的编程大题还难，必要时可以放弃。编程大题就是简单暴力求解可能是做得出来的，但是优化方面就比较难了。