前言
本人是二本院校大二的计算机系学生，已经报名了下一届的蓝桥杯省赛，整个寒假在家（这次的寒假挺久的哈哈）在b站学习了一些算法（现在会bfs走迷宫、dfs相关算法、递归回溯、常见排列算法），但是还是有很多算法都还不太熟悉，做起题来真是费劲。
这是我第二次完整的刷真题，第一次刷的是第七届的真题，其刷题笔记、思路和答案在：
https://blog.csdn.net/cxrshiz7890/article/details/104389137
不得不说，这次刷的第八届题目真是有点难度，开头几道题就难倒我了，花了好长时间想……（我想，考试时如果这样耗着就挂了，所以遇到不会的一定要跳过！）
不过，我相信通过思考总结后，一定会有所收获的！
刷题笔记
注：已完整解答的题目将会标记 （已完成） ，未完全解答出来的题目将在后续更新。代码设计题的代码不代表官方正确解法，只是通过了题目所给的测试而已，因此代码有误还请各位大佬指出哈哈。题目将保留原真题的完整描述，下次复习的时候可以强迫自己多读题（读懂题是关键啊！后面有道题读了十几分钟却不知道题目在讲什么，太浪费时间了！）
第一题、购物单（已完成）
【题目】：
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。
这不，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，不要填写任何多余的内容。
【思路】：
很简单的数学题，逐个相乘然后求和即可。
但是……我还真的那么笨的一个个去算了，写了可能有15分钟吧，还好答案对了，不然到时候考试这么写，真的亏死了。
【正确答案】：
5200
巧妙做法：参考了网上大佬的做法，其实只需要把数据复制到一个空文本里，然后把*****用替换功能全部换成“+”号，把“半价”替换成 “ *0.5 ” (数字前面有个乘号)，然后依次把xx折替换成相应的 “ *0.xx ”（前面有个乘号），最后把这段数据放到编译器里执行就好了。
第二题、纸牌三角形（已完成）
【题目】：
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法（如有对齐问题，参看p1.png）。
A
9 6
4 8
3 7 5 2
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
【思路】：
把三角形展开来看成数组，然后用全排列把数组所有可能列举出来，然后判断有多少种情况符合即可。
这道题，我居然做了1个多小时，还做错了……我把它复杂化了，我分别写了3个方法来判断是否符合边长相等、是否是旋转的情况、是否是镜像的情况。这里记录一下错误的代码……下次复习的时候得长长记性……
package _8s_LanQiao;
import java.util.ArrayList;
import java.util.List;
public class A2
{
static List<String> list = new ArrayList<String>();
static int count = 0;
//全排列
public static void all(int[] a, int step)
{
if(step == a.length - 1)
{
if(checkE(a)) //如果符合边长和一样
{
StringBuffer sb = new StringBuffer();
for(int i = 0; i < a.length; i++)
{
sb.append(a[i]);
}
if(!checkR(a) && !checkM(a)) //如果这种情况不是镜像也不是旋转
{
list.add(sb.toString());
count++;
}
}
}
for(int i = step; i < a.length; i++)
{
int temp = a[i];
a[i] = a[step];
a[step] = temp;
all(a, step + 1);
temp = a[i];
a[i] = a[step];
a[step] = temp;
}
}
//检查旋转
public static boolean checkR(int[] a)
{
int[] ex = new int[a.length*2];
StringBuffer sb = new StringBuffer();
for(int i = 0; i < a.length; i++)
sb.append(a[i]);
String now = sb.toString();
for(int s = 0; s < list.size(); s++)
{
StringBuffer sb2 = new StringBuffer(list.get(s) + list.get(s));
String getstr = sb2.toString();
if(getstr.indexOf(now) != -1) //匹配到了
return true; //这个是旋转的，不符合条件
}
return false;
}
//检查镜像
public static boolean checkM(int[] a)
{
StringBuffer sb = new StringBuffer();
for(int i = 1; i < a.length; i++)
sb.append(a[i]);
String now = a[0] + sb.reverse().toString();
for(int i = 0; i < list.size(); i++)
{
String getstr = list.get(i);
if(getstr.equals(now)) //匹配到了
return true; //说明是镜像，不符合条件
}
return false;
}
//检查是否边长和一样
public static boolean checkE(int[] a)
{
int sum = a[0] + a[1] + a[2] + a[3];
int sum2 = a[3] + a[4] + a[5] + a[6];
int sum3 = a[6] + a[7] + a[8] + a[0];
if(sum == sum2 && sum2 == sum3)
return true; //边长一样，符合条件
else
return false;
}
public static void main(String[] args)
{
int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9,};
all(a, 0);
System.out.println(count); //得出错误答案 288
}
}
除非思路很清晰，否则不要写那么长的代码！！！不要写那么长的代码！！不要写那么长的代码！！很容易出错。
【正确答案】：
144
其实全排列没有错，错的是判断情况的时候。其实只需算出边长相等的情况的次数count，然后再判断这其中包含的重复情况。
重复的情况1、旋转
这里我看错题意了！我以为旋转的意思是9个数字整体顺时针移动1位，真是糊涂啊[捂脸]。这个三角形有3个顶点，旋转的意思应该是从一个顶点到另一个顶点，也就是下面所示：
A 3 2
9 6 旋转 7 4 旋转 8 5
4 8 -----> 5 9 -----> 6 7
3 7 5 2 2 8 6 A A 9 4 3
也就是说，一个数组，就能衍生出其他2种重复的情况，所以总数要除以3，也就是 count / 3 就好了。
重复的情况2、镜像
一开始想的时候我又想复杂了，写了一通代码，结果不知道为何总是运行不了这个方法。
镜像，只有左右两种情况是重复的，count / 2即可。
所以总的来说，count / 3 / 2，就是正确答案了。
第三题、承压计算（已完成）
【题目】：
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
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。
【思路】：
题目的意思就是把当前的数字分成两半，然后分别把一半的重量放在下一层的左右两个东西上，然后下一层的数字也这样重复操作。
从头部截取一部分数据来解释一下我的做法：
5 8
7 8 8
9 2 7 2
1、逐行扫描，把一行当成数组。比如扫到上面部分的第一行，记录当前行：
one = {5, 8}
2、然后另外定义一个“分散数组” arr，用来记录当前行分散（平分）后的值，那么会得到
//arr = {2.5, 2.5 + 4, 4}, 5/2 = 2.5, 8/2 = 4
arr = {2.5, 6.5, 4}
3、上面的分散数组即将堆叠到下一层上。继续记录下一行（7，8，8），把这一行的值加上上一行的分散数组的值(即 one[i] = arr[i] + one[i] )。
//one = {7 + 2.5, 8 + 6.5, 8 + 4}
one = {9.5, 14.5, 12} //这一行的重量，既包括原本该行的重量，又包括上一行的重量
也就是说，下面的金字塔，左侧和右侧是等效的
5 8
7 8 8 ======== 9.5 14.5 12
9 2 7 2 9 2 7 2
然后重复以上步骤累计叠加，最后一行获得的数组就是每个电子秤的值。然后在电子秤上寻找最小值，和题目给出的“2086458231”进行比对，肯定会有比例关系，然后在电子秤上寻找最大值乘以这个比例应该就是最终答案了。
值得注意的是，这样除下去会出现很多的小数（金字塔有29层，小数部分起码会超过小数点后20位），这样会影响我们的判断。于是可以把金字塔每个数字都乘以2^29次方，这样就能保证从头除到尾都不会出现小数了，到时候在从输出的结果中判断即可。
【正确答案】：
72665192664
代码如下：
package _8s_LanQiao;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class A3
{
public static void main(String[] args) throws Exception
{
// Text文件
File file = new File("E:\\1.txt");
// 构造一个BufferedReader类来读取文件
BufferedReader br = new BufferedReader(new FileReader(file));
String s = null;
//上一个数组
long[] last = new long[30];
while ((s = br.readLine()) != null) // 使用readLine方法，一次读一行
{
//拿到一个数组（把当前行变成数组）
String[] one = s.split(" ");
if(one.length == 1) //金字塔顶的数组自己赋值，因为下面for循环赋值不了这个只有单个元素的数组
last[0] = Integer.valueOf(one[0]) * (long)Math.pow(2, 29);
else
{
long[] arr = new long[one.length + 1]; //用来记录"分散后的值"
for(int i = 0; i < one.length - 1; i++)
{
//分散当前数组
long half = last[i] / 2; //记录这个数字的一半的值
arr[i] = arr[i] + half; //这个一半的值会传给下一层左侧的数字
arr[i + 1] = arr[i + 1] + half; //这个一半的值会传给下一层右侧的数字
}
//开始叠加到下个数组
for(int i = 0; i < one.length; i++)
{
last[i] = arr[i] + Integer.valueOf(one[i]) * (long)Math.pow(2, 29);
}
}
}
br.close();
//找到最大值, 这里的最大值就是题目要求出来的值。
long max = last[0];
for(int i = 0; i < last.length; i++)
{
if(last[i] > max)
max = last[i];
}
System.out.println(max); //输出72665192664
}
}
对于上面的代码，我是把金字塔数据放进一个空的txt文本里，然后用网上查的读取文件的方法逐行读取（就是这位大佬的方法），然后构造数组，再进行相应的计算即可。
"1.txt"文件的内容：
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
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
运行后，最后一行数组（全部都是0的那一行）得到的结果是：
2928017717
9614247319
14239908242
18309604302
25052706191
31608660493
35591200180
39001205292
45898456845
52477249327
57251678638
62619220562
69215203679
72544032621
72665192664 //最大值
72404929768
68414729111
63620724941
58101345486
50610064018
46361902021
42903151375
39187912500
36994830636
32752069415
26160343661
19595172402
14435118862
8134346317
2086458231 //最小值
这个就是所谓的每个“电子秤”算出的结果，然后我们就观察每个电子秤上的数值，先找到最小值。最小值就是最后一个，即“2086458231”，这就巧了！这不就是题目提到的数值吗！所以我们只需要找到这其中的最大值，肯定就是电子秤的最大值（也就是正确答案）了。
第四题、魔方状态
注：这道题思路是使用bfs把每种情况列举，然后使用set集合去重，这其中代码很复杂（C语言实现都需要120+行代码），如果到了真正考试的时候，我觉得可以放弃这道题了。
【题目】：
二阶魔方就是只有2层的魔方，只由8个小块组成。
如图p1.png所示。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
第五题、取数位（已完成）
【题目】：
求1个整数的第k位数字有很多种方法。
以下的方法就是一种。
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 ______________________; //填空
}
public static void main(String[] args)
{
int x = 23513;
//System.out.println(len(x));
System.out.println(f(x,3));
}
}
对于题目中的测试数据，应该打印5。
请仔细分析源码，并补充划线部分所缺少的代码。
注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。
【思路】：
1、先观察len() 函数。
static int len(int x){
if(x<10) return 1;
return len(x/10)+1;
}
这个函数的作用和它的名字一样，意思是计算x是几位数。因为这是一个递归函数，返回值是len(x / 10) + 1，也就是说每返回一次，x就会少一位（从最低位开始少），同时会计数一次，当x少到不能再少了（x < 10），返回1，然后再逐个递归返回，就可以得到位数。
上面的话有点拗口，刚接触时我也不懂这个函数是什么意思（新手最头疼的就是递归回溯了），仔细了解了一下终于明白了，用下面方式表示可能更直观一点。
计算len(54321)
递归计算：-----------------------------------------------
len(54321) = len(5432) + 1
len(5432) = len(543) + 1
len(543) = len(54) + 1
len(54) = len(5) + 1
len(5) = 1
回归计算：-----------------------------------------------
len(54) = 1 + 1 = 2
len(543) = 2 + 1 = 3
len(5432) = 3 + 1 = 4
len(54321) = 4 + 1 = 5
2、明白了len()函数的用法后，再来看看f() 函数。
static int f(int x, int k){
if(len(x)-k==0) return x%10;
return ______________________; //填空
}
这里不妨设一个比较极端的例子，x = 321， k = 3作为参数传入执行函数：
f(321,3)
传入参数后，进行if条件判断，可以发现条件成立，直接返回 x % 10 = 1;（从这里发现了，第k位上的数字，其实指的是从左到右数第k个数字）
好的，那么横线上应该填什么呢？我们试着把x = 4321, k = 3传入
f(4321,3)
首先进来，if条件肯定判断不通过，所以需要用到我们填空部分的代码。我们要得到的值是"2"，即 f(4321,3) = 2 .那么怎样才能让if条件通过并返回2呢？
我们可以逆推，如果返回的是2，那么这个2一定是在个位，因为只有这样x %10才能等于2。
所以我们的关键在于，如何把4321变成432，很简单，4321 / 10 = 432. 也就是说，我们需要执行f(432, 3)，那么就会返回2了。所以需要在 f(4321,3) 里面再执行 f(432,3) 所以填空部分是一个递归，也就是：
static int f(int x, int k){
if(len(x)-k==0) return x%10;
return f(x/10, k); //填空
}
【正确答案】：
f(x/10, k);
第六题、最大公共子串（已完成）
【题目】：
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如："abcdkkk" 和 "baabcdadabc"，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
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){
int n = f("abcdkkk", "baabcdadabc");
System.out.println(n);
}
}
【思路】：
可以在草稿本上寻找规律，其实举个例子就很容易得出答案了。（下面写的有点复杂，建议拿纸和笔再写一下，挺容易找到规律的。）
代码中提供了两个字符串，把它们分别转化成了数组c1和c2，然后又开辟了一个二维数组a，行是c1.length + 1, 列是 c2.length + 1, 所以我们不妨画个图走一遍代码流程。
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];
}
}
}
我们需要判断"abcdkkk"和"baabcdadabc"的最大公共子串，那么开辟的二维数组就是如下表格所示。其中：
1、横向是索引j, 纵向是索引i，自动初始化为0, 由于for循环索引从1开始，所以等于0的部分全部用"-"代替。
2、由于不知道划线部分应该填什么，就暂时把a[i][j]赋值为1作为标记，于是能得到以下表格：
| 0 | 1 b | 2 a | 3 a | 4 b | 5 c | 6 d | 7 a | 8 d | 9 a | 10 b | 11 c | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | - | - | - | - | - | - | - | - | - | - | - | - |
| 1 a | - | 0 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 |
| 2 b | - | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
| 3 c | - | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |
| 4 d | - | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0 |
| 5 k | - | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 6 k | - | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 7 k | - | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
通过表格可以得知，公共子串在表格中是以对角线形式存在的，而且很容易知道对角线长度其实就是公共子串的长度。因此，为了记录长度，当执行到
a[i][j]=__________时，这里的值应该是沿着对角线自增1，然后变量max会自动记录最大值。因此答案为：
a[i][j] = a[i-1][j-1] + 1;
【正确答案】：
a[i][j] = a[i-1][j-1] + 1;
第七题、日期问题（已完成）
【题目】：
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在
1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，
有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，
存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
输入
----
一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)
输入
----
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。
样例输入
----
02/03/04
样例输出
----
2002-03-04
2004-02-03
2004-03-02
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
【思路】：
现在回过头来看官网对历年真题的解答，发现之前写的代码存在很大的漏洞！很可能超过一半的数据都不能够通过测试。
错误在于yy_MM_dd(int y, int m, int d) 这个方法中。之前在这个方法中我只判断了（day > 31）的情况，殊不知其实还有很多情况需要判断，比如1、3、5、7、8月才有31天，而2月的情况又要分成闰年（29天） 和 平年（28天）
因此，重新修改一下方法yy_MM_dd(int y, int m, int d) 后的具体思路如下：
1、写一个方法 yy_MM_dd(int y, int m, int d), 参数从左到右分别是指年、月、日。在方法中：
①利用参数y构造年份字符串year;
②利用参数m构造月份字符串month，如果不能构造（如m>12），提前return;
③利用参数d构造日的字符串day，如果不能构造（如d>31），提前return;
然后打印(year + month + day)，即可出来结果。
1、写一个方法 yy_MM_dd(int y, int m, int d), 参数从左到右分别是指年、月、日。
①利用参数y构造年份字符串year；
②利用参数m构造月份的字符串month；如果不能构造（如m>12），提前return;
③利用参数d构造日的字符串day，并进行一系列的判断（如判断该月应该是30天还是31天、该年是闰年还是平年），如果发现不能构造，提前return；
2、输入的形式是 02/03/04，用 数组t 从左到右存储这3个数字。对于输入的日期（如02/03/04），分成以下三种情况（注意方法的参数从左到右是年、月、日）：
①这个“日期”有可能是年/月/日的格式。把02当成年，把03当成月，把04当成日，执行一次方法yy_MM_dd(02,03,04)，也就是yy_MM_dd(t[0],t[1],t[2]).
②这个“日期”也有可能是月/日/年的格式。把02当成月，把03当成日，把04当成年，执行一次方法yy_MM_dd(04,02,03)，也就是yy_MM_dd(t[2],t[0],t[1]).
③这个“日期”也有可能是日/月/年的格式。把02当成日，把03当成月，把04当成年，执行一次方法yy_MM_dd(04,03,02)，也就是yy_MM_dd(t[2],t[1],t[0]).
也就是说，在main里执行3次 yy_MM_dd() 方法，只不过3次执行方法时传入的参数顺序不同。
【参考答案】：
package _8s_LanQiao;
import java.util.Scanner;
public class A7
{
//年--月--日的情况
public static void yy_MM_dd(int y, int m, int d)
{
String year, month, day;
//**********年*********
if(60 <= y && y <= 99)
year = "19" + y;
else if(0 <= y && y <=9)
year = "200" + y;
else
year = "20" + y;
//**********月*********
if(1 <= m && m <= 9)
month = "0" + m;
else if(10 <= m && m <= 12)
month = "" + m;
else
return;
//**********日*********
int max = 30; //记录日的最大值可以是多少(如31、28(平年)、29(闰年))，先初始化为30
int inty = Integer.valueOf(year);
//逐月判断
switch(m)
{
//如果是二月的情况
case 2:
//判断是否是闰年。记住口诀：四年一闰，百年不闰;四百年再闰。
if( (inty % 4 == 0 && inty % 100 != 0 ) || inty % 400 == 0)
max = 29;
else
max = 28;
break;
//每月有31天的情况
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
max = 31;
break;
//其他情况就是每月有30天（已在上面初始化）
}
if(1 <= d && d <= 9)
day = "0" + d;
else if( 10 <= d && d <= max )
day = "" + d;
else
return;
System.out.printf("%s-%s-%s\n", year, month, day);
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String time = sc.nextLine();
String[] t = time.split("/"); //分割
int aa = Integer.valueOf(t[0]);
int bb = Integer.valueOf(t[1]);
int cc = Integer.valueOf(t[2]);
//参数顺序: 年-月-日
yy_MM_dd(aa, bb, cc); //可能是 年-月-日
yy_MM_dd(cc, aa, bb); //可能是 月-日-年
yy_MM_dd(cc, bb, aa); //可能是 日-月-年
}
}
第八题、包子凑数
注：该题代码虽通过了题目给出的测试，但是时间复杂度太高，到真正考试时有可能有些例子会运行超时，等到后面我知道了更优的解法后再回来补充。（考试时这样写应该也能得到一点分的）
建议看官网对该题的讲解！我感觉这道题我的思路不对，以下思路及代码不建议作为解题的参考，建议直接看官网源码（在我自己写的代码后面）。这道题考虑到了使用完全背包（dp）的算法（我还没学习到），具体思路建议到官网看题解。
【题目】：
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中
第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。
每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼
中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买
11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能
放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
----
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)
输出
----
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。
例如，
输入：
2
4
5
程序应该输出：
6
再例如，
输入：
2
4
6
程序应该输出：
INF
样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。
【思路】：
题目简化过来的意思就是：给定几个数(a1,a2, … ,an)，由这几个数随意组合凑正整数（这几个数都有无限个），求出不能凑出正整数的数量。
1、比如（3，4）两个数，1、2、5就凑不出来。
6可以凑出来，3+3；
7也可以，3+4；
8 = 4+4；
9 = 3+3+3；
10 = 3+3+4；
11 = 4+4+3；
12 = 4 + 4 + 4；
—分界线—
13 = 3+3+3+4；
14 = 3+3+4+4；
……
2、再举个例子，（4，5）两个数，1、2、3、6、7凑不出来。
8 = 4+4；
9 = 4+5；
10 = 5+5；
11凑不出来。
12 = 4+4+4；
13 = 4+4+5；
14 = 5+5+4；
15 = 5+5+5；
16 = 4+4+4+4；
17 = 4+4+4+5；
18 = 5+5+4+4；
19 = 5+5+5+4；
20 = 5+5+5+5；
—分界线—
21 = 4+4+4+4+5；
22 = 4+4+4+5+5；
……
通过这两个例子，大胆推测，如果两个数（a，b）组合起来，在区间 [a*b, +∞) 内任意整数都可以通过（a, b）凑出来。因此我们只需要考虑区间 (0, a*b] 内有多少个数不能被表示即可。
于是代码具体步骤如下：
1、比如（3，4）两个数，开辟一个长度为3×4的数组。能凑的数用1标记。
2、列一个方程，3x+4y=C，先固定C，然后再固定y，如果得出x有正整数解，说明这个C可以通过3和4凑出来。比如3x + 4 = 7，存在正整数解x = 1，因此7 可以通过3 + 4凑出来。
（以上步骤另写一个方法 comb(int a, int b) 实现）
3、由于输入的数字不一定只有两个，多个数的话，那就两两分组，依次执行以上方法（开辟的数组长度我大胆推测为两个最小的数之积，然后这个数组需要作为“全局变量”，即多组数据共享这个数组），如果参数a和b都是偶数，那么不执行这个方法。
【参考代码】：
以下是自己写的代码，当测试数据只有2个数字时，代码可通过，未测试多于2个数字时的正确性。建议参考官网源码 （在这段代码的后面）；
package _8s_LanQiao;
import java.util.Arrays;
import java.util.Scanner;
public class A8
{
// ax + by = C --> x = (C - by)/a
public static void comb(int a, int b, int[] book)
{
int count = 0;
for(int C = 1; C < book.length; C++)
{
for(int y = 0; b*y <= C; y++)
{
int x = (C - b * y) / a;
//成立说明x是正整数，可以表示，同时标记book
if(a*x + b*y == C && book[C-1] != 1)
{
book[C-1] = 1;
}
}
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int[] n = new int[N];
for(int i = 0; i < n.length; i++)
n[i] = sc.nextInt();
//初始化标记数组
Arrays.sort(n);
int[] book = new int[n[0] * n[1]];
//两两组合执行方法。
for(int p = 0; p < n.length - 1; p++)
{
for(int q = p + 1; q < n.length; q++)
{
if( !(n[p] % 2 == 0 && n[q] % 2 == 0) )
comb(n[p],n[q], book);
}
}
//算出(0, a*b]区间内有多少个数没被标记(即不能表示)
int count = 0;
for(int i = 0; i < book.length; i++)
{
if(book[i] == 0)
count++;
}
if(count == book.length) //如果开辟的数组一个数都没有标记，那么就输出INF
System.out.println("INF");
else
System.out.println(count - 1);
}
}
【官方题解源码】
public class _08_包子凑数 {
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) {
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);
}
}
第九题、分巧克力（已完成）
【题目】：
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
1. 形状是正方形，边长是整数
2. 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
输出
输出切出的正方形巧克力最大可能的边长。
样例输入：
2 10
6 5
5 6
样例输出：
2
【思路】：
1、按照面积来分。把每块巧克力的面积加起来，然后除以人数，就能得到每个人理论上得到的巧克力的面积（记为sq）。
2、然后把该面积（sq）开根号，得到的数向下取整，作为每块巧克力的边长（记为bian，此时的bian一定是理论上最好的情况）
3、以这个bian为标准，来计算巧克力是否够分。
注意：计算巧克力是否够分时，如果巧克力的最短边小于bian，那么一定要把这个最短边赋值给bian，然后重新计算。
如果不够分，bian–；
4、直到bian减到全部巧克力够分了，输出bian；如果bian等于1，直接输出1；
举例：
1、现有一个6×6的巧克力，8个人分。其总面积为36，理论上每个人得到的巧克力面积为：sq = 36/8 = 4.5
2、sq开根号，得到理论上每个人得到的巧克力的最大边长bian = √4.5 ≈ 2.1213……然后向下取整，即bian = 2；
3、把这个大巧克力的长（为6）除以bian，得到3；把这个巧克力的宽（为6）除以bian，得到3；也就是说，这个巧克力能分出3 × 3 = 9 个bian 为2的巧克力。9 >= 8，够每个人分，直接输出bian = 2。
【参考答案】：
package _8s_LanQiao;
import java.util.Scanner;
public class A9
{
public static void main(String[] args)
{
// System.out.println(Math.sqrt(4.5));
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); //巧克力个数
int K = sc.nextInt(); //人数
int[][] cho = new int[N][2];
int sq = 0; //统计面积
for(int i = 0; i < cho.length; i++) //第i个巧克力
{
//0是宽，1是长
cho[i][0] = sc.nextInt();
cho[i][1] = sc.nextInt();
sq += cho[i][0] * cho[i][1];
}
//返回平方根，强转为int只保留整数部分，相当于向下取整
int bian = (int)Math.sqrt(sq);
while(true)
{
int count = 0;
for(int i = 0; i < cho.length; i++)
{
int m = cho[i][0] / bian; //看宽能容纳多大的bian
int n = cho[i][1] / bian; //看长能容纳多大的bian
int min = Math.min(cho[i][0], cho[i][1]);
if(min < bian) //保证bian小于等于每个巧克力的最短边。
{
bian = min;
i = -1;
count = 0;
continue;
}
count += m * n;
}
if(count >= K || bian == 1)
break;
else
bian --;
}
System.out.println(bian);
}
}
第十题、k倍区间（已完成）
注：该题代码运用的是暴力法，可能有些测试会超时，如果等到后面知道了更优的解法，再回来补充。
【题目】：
给定一个长度为N的数列，A1, A2, ... AN，如果其中一段连续的子序列Ai, Ai+1, ... Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
输入
-----
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)
输出
-----
输出一个整数，代表K倍区间的数目。
例如，
输入：
5 2
1
2
3
4
5
程序应该输出：
6
【思路】：
想着这个是最后一题了，按照我刷题的速度，考试时写到这一题，时间也应该所剩无几了。所以花了不到10分钟写了一个暴力法。
就是把这个数组的所有公共子串列举出来，然后统计总和，如果总和是k的倍数，计数count++即可。
【参考答案】：
package _8s_LanQiao;
import java.util.Scanner;
public class A10
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); //有多少个元素
int K = sc.nextInt();
int[] arr = new int[N];
for(int i = 0; i < arr.length; i++)
arr[i] = sc.nextInt();
int count = 0;
for(int i = 0; i < arr.length; i++)
{
int sum = 0;
for(int j = i; j < arr.length; j++)
{
sum += arr[j];
if(sum % K == 0) //成倍数
count ++;
}
}
System.out.println(count);
}
}
总结
刷题其实就是为了积累经验，能够在刷题的过程认识到自己缺失的知识点，那么刷题就是有效果的。以上所有代码仅供参考，不代表官方解法（官方源码除外）。其实代码也不是注重于结果，而是注重刷题时的思考过程，熟悉了各种题目的套路考试起来才能得心应手啊。
