目录
引言
边吃饭边做题，新鲜的题目详解，虽然所有学校的考试时间都不一样，不过本文是在考试刚结束就开始编写了，对我来说是brandnew的。
这是我去年写的博客，今年又出现不少原题：
去年原题部分
结果填空
1. 签到题
问题描述
在计算机存储中，15.125GB是多少MB？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解：
计算器按一下就好了。
15488
2. 概念题
问题描述
1200000有多少个约数（只计算正约数）。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解：
被这题卡住，需要谷歌一下约数的概念。
96
3. 签到题
问题描述
一棵包含有2019个结点的树，最多包含多少个叶结点？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解：
2018叉树不就是2018个叶节点，说来想起我课设写的好像是个类三叉树。
2018
4. 签到题
问题描述
在1至2019中，有多少个数的数位中包含数字9？
注意，有的数中的数位中包含多个9，这个数只算一次。例如，1999这个数包含数字9，在计算只是算一个数。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解：
签到题，从这一题开始写了代码。
544
很简单的代码。
public class M2020T4 {
static boolean contain9(int num) {
while (num != 0) {
if (num % 10 == 9) {
return true;
} else {
num /= 10;
}
}
return false;
}
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <= 2019; i++) {
if (contain9(i)) {
count++;
}
}
System.out.println(count);
}
}
程序题
5. 递增三元组[遍历]
去年原题，接着暴力玩，其实可以最长上升子序列之类的做法。
问题描述
在数列 a[1], a[2], ..., a[n] 中，如果对于下标 i, j, k 满足 0<i<j<k<n+1 且 a[i]<a[j]<a[k]，则称 a[i], a[j], a[k] 为一组递增三元组，a[j]为递增三元组的中心。
给定一个数列，请问数列中有多少个元素可能是递增三元组的中心。
输入格式
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], ..., a[n]，相邻的整数间用空格分隔，表示给定的数列。
输出格式
输出一行包含一个整数，表示答案。
样例输入
5
1 2 5 3 5
样例输出
2
样例说明
a[2] 和 a[4] 可能是三元组的中心。
评测用例规模与约定
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
题解：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class M2020T5 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// reader = new BufferedReader(new StringReader("5\n" +
// "1 2 5 3 5"));
reader.readLine();
String[] split = reader.readLine().split(" ");
int[] a = new int[split.length];
for (int i = 0; i < split.length; i++) {
a[i] = Integer.parseInt(split[i]);
}
int count = 0;
for (int i = 0; i < a.length; i++) {
for (int j = i + 1; j < a.length; j++) {
for (int k = j + 1; k < a.length; k++) {
if (a[i] < a[j] && a[j] < a[k]) {
a[j] = Integer.MAX_VALUE;
count++;
}
}
}
}
System.out.println(count);
}
}
6. 小明的hello[循环]
考察substring的用法？
问题描述
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
输入格式
输入一行，包含一个单词，单词中只包含小写英文字母。
输出格式
输出答案，或者为yes，或者为no。
样例输入
lanqiao
样例输出
yes
样例输入
world
样例输出
no
评测用例规模与约定
对于所有评测用例，单词中的字母个数不超过100。
题解：
让我们轻松给出直接正则的做法：
^([bcdfghjklmnpqrstvwxyz]+)([aeiou]+)([bcdfghjklmnpqrstvwxyz]+)([aeiou]+)$
好了上面的如果想不出来，我们还有正常做法：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class M2020T6 {
static char[] yuan = {'a', 'e', 'i', 'o', 'u'};
static boolean checkYuan(char input) {
for (char c : yuan) {
if (input == c) {
return true;
}
}
return false;
}
static boolean check(String input) {
boolean flag1 = false;
boolean flag2 = false;
boolean flag3 = false;
boolean flag4 = false;
while (!checkYuan(input.charAt(0))) {
flag1 = true;
input = input.substring(1);
if (input.equals("")) {
return false;
}
}
if (!flag1) {
return false;
}
while (checkYuan(input.charAt(0))) {
flag2 = true;
input = input.substring(1);
if (input.equals("")) {
return false;
}
}
if (!flag2) {
return false;
}
while (!checkYuan(input.charAt(0))) {
flag3 = true;
input = input.substring(1);
if (input.equals("")) {
return false;
}
}
if (!flag3) {
return false;
}
while (checkYuan(input.charAt(0))) {
flag4 = true;
input = input.substring(1);
if (input.equals("")) {
return true;
}
}
if (!flag4) {
return false;
}
if (checkYuan(input.charAt(0))) {
flag1 = false;
}
return flag1;
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// reader = new BufferedReader(new StringReader("lanqiao"));
String input = reader.readLine();
if (check(input)) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
}
7. 数位递增[数位dp]
自己想了暴力，但是能看出来有很大优化空间，然后找到了数位dp。
问题描述
一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
输入格式
输入的第一行包含一个整数 n。
输出格式
输出一行包含一个整数，表示答案。
样例输入
30
样例输出
26
评测用例规模与约定
对于 40% 的评测用例，1 <= n <= 1000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
题解：
给一套骚操作。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class M2020T7 {
public static int n = 0, count = 0;
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// reader = new BufferedReader(new StringReader("30"));
n = Integer.parseInt(reader.readLine());
check(0, 1);
System.out.println(count - 1);
}
private static void check(int num, int temp) {
if (num > n) {
return;
} else {
count++;
}
for (int i = temp; i < 10; i++) {
check(num * 10 + i, i);
}
}
}
8. 小明家的草地[bfs]
bfs，不过我选择暴力（。
问题描述
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
请告诉小明，k 个月后空地上哪些地方有草。
输入格式
输入的第一行包含两个整数 n, m。
接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
接下来包含一个整数 k。
输出格式
输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
样例输入
4 5
.g...
.....
..g..
.....
2
样例输出
gggg.
gggg.
ggggg
.ggg.
评测用例规模与约定
对于 30% 的评测用例，2 <= n, m <= 20。
对于 70% 的评测用例，2 <= n, m <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000。
题解：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class M2020T8 {
static void print(boolean[][] ground) {
StringBuilder result = new StringBuilder();
for (boolean[] booleans : ground) {
for (boolean aBoolean : booleans) {
if (aBoolean) {
result.append('g');
} else {
result.append('.');
}
}
result.append('\n');
}
System.out.print(result);
}
static boolean[][] clone(boolean[][] ground) {
boolean[][] result = new boolean[ground.length][ground[0].length];
for (int i = 0; i < ground.length; i++) {
System.arraycopy(ground[i], 0, result[i], 0, ground[i].length);
}
return result;
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// reader = new BufferedReader(new StringReader("4 5\n" +
// ".g...\n" +
// ".....\n" +
// "..g..\n" +
// ".....\n" +
// "2"));
String[] split = reader.readLine().split(" ");
int n = Integer.parseInt(split[0]);
int m = Integer.parseInt(split[1]);
boolean[][] ground = new boolean[n][m];
for (int i = 0; i < n; i++) {
String line = reader.readLine();
for (int j = 0; j < m; j++) {
char ch = line.charAt(j);
if (ch == 'g') {
ground[i][j] = true;
}
}
}
int k = Integer.parseInt(reader.readLine());
for (int i = 0; i < k; i++) {
boolean[][] tmp = clone(ground);
for (int j = 0; j < n; j++) {
for (int l = 0; l < m; l++) {
if (tmp[j][l]) {
if (j > 0) {
ground[j - 1][l] = true;
}
if (j < n - 1) {
ground[j + 1][l] = true;
}
if (l > 0) {
ground[j][l - 1] = true;
}
if (l < m - 1) {
ground[j][l + 1] = true;
}
}
}
}
}
print(ground);
}
}
9. 小明的正整数序列[dfs]
这题把我卡住了。
是一道dfs，用数组记忆一下已有的结果，这题跟学长讨论的结果是没办法只用一次dfs实现，因为初始的结束条件与接下来的结束条件不一致，我就卡在了这。
问题描述
小明想知道，满足以下条件的正整数序列的数量：
1. 第一项为 n；
2. 第二项不超过 n；
3. 从第三项开始，每一项小于前两项的差的绝对值。
请计算，对于给定的 n，有多少种满足条件的序列。
输入格式
输入一行包含一个整数 n。
输出格式
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
样例输入
4
样例输出
7
样例说明
以下是满足条件的序列：
4 1
4 1 1
4 1 2
4 2
4 2 1
4 3
4 4
评测用例规模与约定
对于 20% 的评测用例，1 <= n <= 5；
对于 50% 的评测用例，1 <= n <= 10；
对于 80% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 1000。
题解：
我们可以用小学二年级知识轻松口算出时间复杂度O（1）的代码：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
public class M2020T9 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
reader = new BufferedReader(new StringReader("4"));
int n = Integer.parseInt(reader.readLine());
int[] ans = {0, 1, 2, 4, 7, 14, 26, 53, 106, 220, 452, 946, 1967, 4128, 8638, 8144, 8068, 26, 8127, 3542, 3277, 3278, 7643, 5433, 5774, 8217, 4846, 687, 3097, 6887, 3556, 4840, 3454, 5378, 722, 2230, 767, 1447, 1839, 4776, 7618, 7831, 6222, 5236, 7802, 5696, 1835, 1102, 9537, 1605, 1227, 3034, 2159, 1613, 6811, 3941, 6794, 5960, 4903, 75, 2158, 349, 4258, 5189, 4717, 2894, 4193, 2890, 258, 2928, 6125, 2913, 1482, 8419, 7244, 1652, 3440, 2138, 9272, 4714, 3333, 3543, 8834, 6763, 9180, 1803, 4631, 6307, 9056, 3170, 8339, 6213, 1176, 3258, 272, 4257, 1893, 8020, 3682, 9531, 6961, 4145, 3086, 3455, 9057, 1346, 5768, 6907, 247, 2450, 4732, 8653, 8229, 842, 3346, 9671, 7106, 3561, 4952, 9539, 1791, 6208, 6083, 8838, 7474, 6854, 198, 7300, 8219, 5912, 8884, 3976, 9650, 4821, 7317, 9720, 5572, 3834, 6326, 2281, 34, 8409, 28, 445, 8155, 9846, 9944, 2504, 3954, 1639, 7243, 8502, 6926, 1609, 7449, 3769, 5695, 6683, 7531, 6275, 5827, 6184, 1982, 736, 9718, 2777, 7688, 6626, 7456, 961, 5556, 7573, 6886, 4543, 3957, 2859, 4666, 9795, 305, 9052, 5350, 9827, 5445, 6970, 2599, 7566, 2848, 2987, 5179, 1537, 2392, 6375, 9621, 7376, 3301, 1357, 6545, 7838, 9390, 4284, 2631, 1814, 2566, 7666, 1110, 5694, 7595, 5000, 1290, 4735, 5994, 9401, 6475, 9012, 5877, 2867, 7912, 3509, 5505, 885, 7490, 5622, 4374, 8721, 5134, 8788, 5430, 3869, 9852, 5762, 75, 5964, 262, 5565, 1599, 7525, 5388, 8612, 1143, 7938, 7580, 2953, 7901, 5629, 1456, 9852, 5216, 965, 3739, 7879, 1212, 9029, 9263, 9609, 1926, 8151, 1997, 6298, 5125, 5715, 4864, 3852, 604, 7652, 313, 6248, 4077, 3875, 3816, 7046, 9525, 3798, 6959, 9366, 2216, 4463, 6546, 6367, 614, 9477, 3176, 4098, 7162, 7535, 4696, 749, 2686, 8212, 9050, 255, 1389, 287, 1086, 9414, 9897, 2293, 31, 9121, 4682, 7084, 8951, 834, 1051, 2236, 3712, 6426, 8642, 185, 785, 8162, 6015, 658, 8923, 5741, 2551, 7629, 2095, 8882, 7695, 5629, 8684, 5116, 6362, 7701, 9441, 9403, 1108, 4395, 5688, 9466, 953, 9191, 4967, 7236, 6020, 3465, 8165, 872, 4530, 3353, 7859, 1422, 1504, 6366, 126, 1246, 1530, 1777, 8970, 4590, 2195, 6920, 9086, 689, 2163, 6035, 4961, 2055, 7699, 4121, 3971, 1824, 3707, 4405, 854, 6088, 6971, 1679, 1779, 7097, 5696, 2449, 2104, 3264, 796, 8595, 6183, 26, 5597, 7295, 5926, 9039, 4550, 9601, 5959, 3244, 7451, 5641, 2343, 6587, 3755, 4361, 3890, 446, 8187, 1979, 7000, 7094, 8658, 1647, 6090, 8332, 4407, 4570, 2340, 3057, 5029, 5424, 2736, 4844, 2771, 5782, 5912, 3745, 2504, 2782, 7247, 1393, 5403, 7175, 9903, 1723, 7600, 7021, 4566, 9778, 5188, 46, 8542, 7915, 5043, 4983, 519, 480, 8199, 1141, 73, 9316, 6248, 966, 3218, 6614, 6974, 5078, 9775, 7263, 6263, 7267, 1947, 5357, 286, 674, 3876, 1985, 4731, 1850, 512, 1493, 5310, 5443, 4183, 5963, 8642, 1389, 6320, 4264, 9565, 7348, 4378, 6192, 1300, 3393, 4794, 8323, 6063, 9651, 9368, 7899, 9053, 4933, 5140, 5604, 9114, 9299, 7603, 2485, 884, 7313, 4139, 9883, 1405, 9843, 7419, 1483, 2031, 8610, 4150, 3313, 6257, 3790, 1688, 994, 1357, 9660, 583, 5735, 1548, 7156, 9678, 8047, 3617, 9611, 7966, 7764, 5177, 7716, 4206, 7985, 6989, 6318, 5854, 8292, 9639, 687, 370, 3252, 7104, 5813, 758, 8219, 3809, 2506, 3605, 9340, 3559, 4118, 4757, 8229, 4258, 944, 1596, 4940, 622, 5832, 1270, 6948, 1744, 1125, 7895, 9348, 7601, 7426, 1975, 9611, 3722, 4143, 4979, 7904, 3221, 3817, 5755, 1798, 6549, 3463, 3190, 201, 6894, 6209, 3488, 670, 7643, 7020, 6164, 5583, 5036, 6309, 8644, 7961, 3465, 7795, 1486, 4535, 3111, 5252, 4049, 4253, 7515, 1517, 6148, 2438, 1296, 8826, 7924, 7761, 9126, 6951, 7110, 7549, 1170, 8533, 793, 1633, 6451, 6261, 5887, 8694, 6447, 8993, 6398, 1289, 2925, 2362, 3935, 6744, 1358, 1743, 3937, 9942, 3696, 1601, 8295, 3086, 2595, 9554, 8566, 1465, 2109, 3474, 3950, 9216, 8948, 2020, 3536, 943, 4934, 8377, 6171, 1243, 3525, 259, 3001, 4205, 4548, 4754, 2365, 8630, 4690, 7872, 5131, 3995, 2672, 728, 6532, 9785, 9379, 5865, 4774, 6660, 3721, 4451, 9085, 4771, 8008, 857, 9737, 5630, 4040, 3106, 5997, 4152, 8542, 3992, 3294, 5064, 2656, 5247, 635, 1521, 3026, 1502, 9396, 2171, 7188, 2425, 9758, 2640, 8648, 9454, 274, 9471, 8972, 9301, 911, 6023, 4155, 126, 7802, 2948, 5675, 6313, 69, 1374, 9925, 3685, 6901, 432, 1884, 4803, 8173, 9638, 3626, 695, 4286, 3836, 8670, 8834, 1444, 5187, 6281, 2482, 8801, 7656, 9066, 5138, 5160, 9857, 906, 5235, 7243, 5281, 5103, 5826, 5023, 3637, 5607, 1204, 5697, 3422, 1192, 8753, 6087, 2083, 3256, 8201, 9853, 1886, 3953, 4732, 7351, 6387, 9148, 2299, 4843, 3891, 3572, 874, 9873, 1235, 7323, 8860, 3439, 113, 5132, 6521, 1234, 7427, 4062, 1342, 2480, 641, 8802, 9788, 5336, 3649, 1301, 3268, 749, 1628, 9202, 2689, 3284, 9170, 5252, 1577, 1705, 5640, 2185, 2252, 4943, 271, 5117, 8699, 2743, 8221, 2119, 3851, 701, 2740, 4247, 7037, 9764, 4445, 5848, 6135, 6166, 5328, 2584, 1131, 3005, 8817, 2783, 7749, 6112, 5567, 9688, 2549, 7929, 8650, 60, 1896, 3998, 7345, 3352, 8990, 1143, 873, 1191, 5821, 9485, 5249, 3086, 8016, 9319, 4139, 3566, 8871, 7528, 7873, 4117, 1085, 7064, 8222, 5947, 4447, 1326, 5206, 12, 9703, 5711, 3951, 219, 6966, 3168, 2372, 9603, 9092, 1904, 1010, 2704, 2106, 7568, 3410, 296, 6825, 9781, 637, 4465, 7953, 6861, 2142, 2035, 9743, 1921, 3051, 7424, 7112, 7676, 5245, 9531, 2284, 4498, 6423, 6977, 3106, 1367, 5696, 2003, 1291, 3025, 76, 3147, 9094, 4580, 5097, 7390, 8637, 5853, 359, 3153, 4957, 6635, 5721, 3353, 2266, 3481, 7432, 3020, 7330, 1172, 5285, 1525, 2928, 5331, 8856, 2163, 5169, 1465, 4439, 1876, 7446, 2192, 5577, 726, 6599, 352, 3645, 7733, 8331, 5447, 8017, 5017, 7287, 6602, 7248, 6323, 4195, 9617, 2263, 4013, 450, 4073, 6131, 3569, 9019, 1858, 9827, 8118, 4972, 7422, 9666, 5760, 9213, 2817, 7952, 3948, 8683, 3645, 6402, 3264, 1919, 9276, 2519, 190, 766, 8940, 3413, 2644, 8048, 83, 9724, 7009, 3777, 9663, 2483, 5752, 4578, 8951, 5902, 2170, 9967, 894, 8556, 6049, 7254, 2746, 8962, 8317, 6848, 767, 7907, 1028, 9458, 6881, 4978, 6717, 8210, 3835, 1064, 7434, 746, 9449};
System.out.println(ans[n]);
}
}
如果口算不出来，看这个：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class M2020T9_1 {
static int[][] ans = new int[1001][1001];
static int dfs(int pre, int now) {
if (ans[pre][now] != -1) {
return ans[pre][now];
}
int result = 1;
for (int i = 1; i < Math.abs(pre - now); i++) {
result += dfs(now, i);
result %= 10000;
}
ans[pre][now] = result;
return result;
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// reader = new BufferedReader(new StringReader("4"));
int n = Integer.parseInt(reader.readLine());
for (int[] an : ans) {
Arrays.fill(an, -1);
}
int result = 0;
for (int i = 1; i <= n; i++) {
result += dfs(n, i);
result %= 10000;
}
System.out.println(result);
}
}
10. 好看的节目[结构体排序]
和上次模拟一样的题目，不说了。
输入格式
输入的第一行包含两个整数 n, m ，表示节目的数量和要选择的数量。
第二行包含 n 个整数，依次为每个节目的好看值。
输出格式
输出一行包含 m 个整数，为选出的节目的好看值。
样例输入
5 3
3 1 2 5 4
样例输出
3 5 4
样例说明
选择了第1, 4, 5个节目。
评测用例规模与约定
对于 30% 的评测用例，1 <= n <= 20；
对于 60% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 100000，0 <= 节目的好看值 <= 100000。
题解：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Comparator;
public class M2020T10 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
// reader = new BufferedReader(new StringReader("5 3\n" +
// "3 1 2 5 4"));
String[] split = reader.readLine().split(" ");
int n = Integer.parseInt(split[0]);
int m = Integer.parseInt(split[1]);
split = reader.readLine().split(" ");
Program[] all = new Program[n];
for (int i = 0; i < n; i++) {
all[i] = new Program(i, Integer.parseInt(split[i]));
}
Arrays.sort(all, new Comparator<Program>() {
@Override
public int compare(Program program, Program t1) {
return t1.score - program.score;
}
});
Program[] all2 = Arrays.copyOf(all, m); // light
Arrays.sort(all2, new Comparator<Program>() {
@Override
public int compare(Program program, Program t1) {
return program.id - t1.id;
}
});
for (int i = 0; i < m; i++) {
System.out.print(all2[i].score + " ");
}
}
}
class Program {
int id;
int score;
Program(int id, int score) {
this.id = id;
this.score = score;
}
}
后记
感觉应该看点概念类的了，考试的时候不知道约数是什么，尴尬。
除了第九题卡住了思路，其他应该没什么问题，对我的题解有疑问可以评论或私信。
因为博主本人比较菜鸡，目前还在慢慢刷题，想一起学习的可以加我。