2019年第十屆藍橋杯[Java省賽B組]
試題 A: 組隊
試題 A: 組隊
本題總分：5 分
【問題描述】
作為籃球隊教練，你需要從以下名單中選出 1 號位至 5 號位各一名球員，
組成球隊的首發陣容，
每位球員擔任 1 號位至 5 號位時的評分如下表所示，請你計算首發陣容 1
號位至 5 號位的評分之和最大可能是多少？
答案: 490
試題B: 不同子串
試題 B: 不同子串
本題總分：5 分
【問題描述】
一個字串的非空子串是指字串中長度至少為 1 的連續的一段字符組成
的串，例如，字串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 個，
注意在計算時，只算本質不同的串的個數，
請問，字串0100110001010001 有多少個不同的非空子串？
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一
個整數，在提交答案時只填寫這個整數，填寫多余的內容將無法得分，
解題思路:
可暴力列舉所有可以一一對比
也可使用set集合add進行添加進集合中,set集合會去重,輸出set集合中的長度及最終答案
代碼:
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
Scanner sc = new Scanner(System.in);
String str = sc.next();
for(int i = 0; i < str.length(); i++) {
for(int j = i; j < str.length(); j++) {
set.add(str.substring(i, j + 1));
}
}
System.out.println(set.size());
sc.close();
}
}
答案:100
試題C: 數列求值
試題 C: 數列求值
本題總分：10 分
【問題描述】
給定數列 1, 1, 1, 3, 5, 9, 17, …，從第 4 項開始，每項都是前 3 項的和，求
第 20190324 項的最后 4 位數字，
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一
個 4 位整數（提示：答案的千位不為 0），在提交答案時只填寫這個整數，填寫
多余的內容將無法得分，
解題思路:
斐波那契數列,每次回圈后都需要進行取模
public class Main {
public static void main(String[] args) {
int[] n = new int[20190330];
n[0] = 0;
n[1] = 1;
n[2] = 1;
n[3] = 1;
for(int i = 4; i < n.length; i++) {
n[i] = (n[i - 1] + n[i - 2] + n[i - 3]) % 10000;
}
System.out.println(n[20190324]);
}
}
答案: 4659
試題D: 數的分解
試題 D: 數的分解
本題總分：10 分
【問題描述】
把 2019 分解成 3 個各不相同的正整數之和，并且要求每個正整數都不包
含數字 2 和 4，一共有多少種不同的分解方法？
注意交換 3 個整數的順序被視為同一種方法，例如 1000+1001+18 和
1001+1000+18 被視為同一種，
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一
個整數，在提交答案時只填寫這個整數，填寫多余的內容將無法得分，
暴力破解
代碼:
public class Main {
public static void main(String[] args) {
int sum = 0;
for(int i = 1; i <= 2019; i++) {
for(int j = 1; j < i; j++) {
for(int k = 1; k < j; k++) {
if(check(i) && check(j) && check(k)) {
if(i + j + k == 2019) {
sum++;
//System.out.println(i + " + " + j + " + " + k);
}
}
}
}
}
System.out.println(sum++);
}
private static boolean check(int i) {
boolean flag = true;
while(i > 0) {
if(i % 10 == 2 || i % 10 == 4) {
flag = false;
}
i /= 10;
}
return flag;
}
}
答案:40785
試題E: 迷宮
試題 E: 迷宮
本題總分：15 分
【問題描述】
下圖給出了一個迷宮的平面圖，其中標記為 1 的為障礙，標記為 0 的為可以通行的地方，
010000
000100
001001
110000
迷宮的入口為左上角，出口為右下角，在迷宮中，只能從一個位置走到這個它的上、下、左、右四個方向之一，
對于上面的迷宮，從入口開始，可以按DRRURRDDDR 的順序通過迷宮，一共 10 步，其中 D、U、L、R 分別表示向下、向上、向左、向右走，
對于下面這個更復雜的迷宮（30 行 50 列），請找出一種通過迷宮的方式，其使用的步數最少，在步數最少的前提下，請找出字典序最小的一個作為答案，請注意在字典序中D<L<R<U，（如果你把以下文字復制到文本檔案中，請務必檢查復制的內容是否與檔案中的一致，在試題目錄下有一個檔案 maze.txt，內容與下面的文本相同）
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一個字串，包含四種字母 D、U、L、R，在提交答案時只填寫這個字串，填寫多余的內容將無法得分，
解題思路:
經典的迷宮問題，使用dfs會出現堆疊溢位且運行效率低，
故使用bfs演算法求最短路徑，圖的遍歷時按照題目所給的字典序進行從小到大的遍歷
代碼:
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main {
private static int[][] dir = new int[][] {{1,0},{0,-1},{0,1},{-1,0}};
private static String[][] ans = new String[30][50]; //方向
private static char[][] arr = new char[30][50];
private static int[][] len = new int[30][50]; //長度
private static int[][] vis = new int[30][50];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
for(int i = 0; i < 30; i++) {
String str = sc.next();
for(int j = 0; j < 50; j++) {
arr[i][j] = str.charAt(j);
}
}
bfs(0,0);
String str = ans[29][49];
//System.out.println(len[29][49]);
for(int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if(ch == '0') {
System.out.print("D");
}else if(ch == '1') {
System.out.print("L");
}
else if(ch == '2') {
System.out.print("R");
}
else if(ch == '3') {
System.out.print("U");
}
}
sc.close();
}
private static void bfs(int x, int y) {
// TODO Auto-generated method stub
Queue<Node> queue = new LinkedList<>();
queue.add(new Node(x, y));
vis[x][y] = 1;
ans[0][0] = "";
while(!queue.isEmpty()) {
Node node = queue.poll();
for(int i = 0; i < 4; i++) {
int newx = node.x + dir[i][0];
int newy = node.y + dir[i][1];
if(newx>=0 && newx<30 && newy>=0 && newy<50 && vis[newx][newy]==0 && arr[newx][newy]=='0') {
vis[newx][newy] = 1;
len[newx][newy] = len[node.x][node.y] + 1;
ans[newx][newy] = ans[node.x][node.y] + String.valueOf(i);
queue.add(new Node(newx, newy));
}
}
}
}
}
class Node{
int x;
int y;
public Node(int x, int y) {
this.x = x;
this.y = y;
}
}
答案:
DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
試題F: 特別數的和
試題 F: 特別數的和
時間限制: 1.0s 記憶體限制: 512.0MB 本題總分：15 分
【問題描述】
小明對數位中含有 2、0、1、9 的數字很感興趣（不包括前導 0），在 1 到
40 中這樣的數包括 1、2、9、10 至 32、39 和 40，共 28 個，他們的和是 574，
請問，在 1 到 n 中，所有這樣的數的和是多少？
【輸入格式】
輸入一行包含兩個整數 n，
【輸出格式】
輸出一行，包含一個整數，表示滿足條件的數的和，
【樣例輸入】
40
【樣例輸出】
574
【評測用例規模與約定】
對于 20% 的評測用例，1 ≤ n ≤ 10，
對于 50% 的評測用例，1 ≤ n ≤ 100，
對于 80% 的評測用例，1 ≤ n ≤ 1000，
對于所有評測用例，1 ≤ n ≤ 10000，
解題思路:
將數字轉換為String型別,用String中的contains方法進行判斷是否滿足條件
代碼:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = 0;
for(int i = 1; i <= n; i++) {
String str = Integer.toString(i);
if(str.contains("2") || str.contains("0") || str.contains("1") || str.contains("9")) {
sum += i;
}
}
System.out.println(sum);
sc.close();
}
}
試題G: 外賣店優先級
試題 G: 外賣店優先級
時間限制: 1.0s 記憶體限制: 512.0MB 本題總分：20 分
【問題描述】
“飽了么”外賣系統中維護著 N 家外賣店，編號 1 ～ N，每家外賣店都有一個優先級，初始時 (0 時刻) 優先級都為 0，
每經過 1 個時間單位，如果外賣店沒有訂單，則優先級會減少 1，最低減到 0；而如果外賣店有訂單，則優先級不減反加，每有一單優先級加 2，如果某家外賣店某時刻優先級大于 5，則會被系統加入優先快取中；如果優先級小于等于 3，則會被清除出優先快取，
給定 T 時刻以內的 M 條訂單資訊，請你計算 T 時刻時有多少外賣店在優先快取中，
【輸入格式】
第一行包含 3 個整數 N、M 和 T，
以下 M 行每行包含兩個整數 ts 和 id，表示 ts 時刻編號 id 的外賣店收到
一個訂單，
【輸出格式】
輸出一個整數代表答案，
【樣例輸入】
2 6 6
1 1
5 2
3 1
6 2
2 1
6 2
【樣例輸出】
1
【樣例解釋】
6 時刻時，1 號店優先級降到 3，被移除出優先快取；2 號店優先級升到 6，
加入優先快取，所以是有 1 家店 (2 號) 在優先快取中，
【評測用例規模與約定】
對于 80% 的評測用例，1 ≤ N, M, T ≤ 10000，
對于所有評測用例，1 ≤ N, M, T ≤ 100000，1 ≤ ts ≤ T，1 ≤ id ≤ N，
試題決議:
此題可以使用set集合來存放優先快取,通過遍歷時間判斷當前時段店鋪是否達到優先級加入快取區,或者小于優先級清除快取區
代碼:
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Set<Integer> set = new HashSet<Integer>();
int N = sc.nextInt();
int M = sc.nextInt();
int T = sc.nextInt();
int[][] orders = new int[M][2];
for(int i = 0; i < M; i++) {
for(int j = 0; j < 2; j++) {
orders[i][j] = sc.nextInt();
}
}
int[] p = new int[N];
int[] s = new int[N];
for(int i = 1; i <= T; i++) {
for(int j = 0;j < M; j++) {
if(orders[j][0] == i) {
p[orders[j][1] - 1] += 2;
if(p[orders[j][1] - 1] > 5 && !set.contains(orders[j][1] - 1)) {
set.add(orders[j][1] - 1);
}
s[orders[j][1] - 1] = 1;
}
}
for(int j = 0; j < N; j++) {
if(s[j] == 0 && p[j] > 0) {
p[j]--;
}
if(p[j] <= 3) {
set.remove(j);
}
}
s = new int[N];
}
System.out.println(set.size());
sc.close();
}
}
試題H: 人物相關性分析
試題 H: 人物相關性分析
時間限制: 1.0s 記憶體限制: 512.0MB 本題總分：20 分
【問題描述】
小明正在分析一本小說中的人物相關性，他想知道在小說中 Alice 和 Bob
有多少次同時出現，
更準確的說，小明定義 Alice 和 Bob“同時出現”的意思是：在小說文本中 Alice 和 Bob 之間不超過 K 個字符，
例如以下文本：
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
假設 K = 20，則 Alice 和 Bob 同時出現了 2 次，分別是”Alice and Bob”和”Bob. Alice”，前者 Alice 和 Bob 之間有 5 個字符，后者有 2 個字符，
注意:
1.Alice 和 Bob 是大小寫敏感的，alice 或 bob 等并不計算在內，
2.Alice 和 Bob 應為單獨的單詞，前后可以有標點符號和空格，但是不能有字母，例如 Bobbi 並不算出現了 Bob，
【輸入格式】
第一行包含一個整數 K，
第二行包含一行字串，只包含大小寫字母、標點符號和空格，長度不超過 1000000，
【輸出格式】
輸出一個整數，表示 Alice 和 Bob 同時出現的次數，
【樣例輸入】
20
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
【樣例輸出】
2
【評測用例規模與約定】
對于所有評測用例，1 ≤ K ≤ 1000000，
試題決議:
使用List集合分別記錄兩個字串中Alice和Bob中首字母的下標,遍歷找出符合條件Alice和Bob的個數
代碼:
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int K = sc.nextInt();
sc.nextLine();
String str = sc.nextLine();
List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
for(int i = 0; i <= str.length() - 5; i++) {
if((i==0 || !check(str.charAt(i - 1))) && (i+5==str.length() || !check(str.charAt(i + 5)))) {
if(str.substring(i, i + 5).equals("Alice")) {
list1.add(i);
}
}
}
for(int i = 0; i <= str.length() - 3; i++) {
if((i==0 || !check(str.charAt(i - 1))) && (i+3==str.length() || !check(str.charAt(i + 3)))) {
if(str.substring(i, i + 3).equals("Bob")) {
list2.add(i);
}
}
}
long sum = 0;
for(int i = 0, l = 0, r = 0; i < list1.size(); i++) {
while(r < list2.size() && list1.get(i) >= list2.get(r)) {
r++;
}
while((l < r) && list1.get(i) - list2.get(l) - 3 >= K) {
l++;
}
sum += r - l;
}
for(int i = 0, l = 0, r = 0; i < list2.size(); i++) {
while(r< list1.size() && list2.get(i) >= list1.get(r)){
r++;
}
while(l < r && list2.get(i) - list1.get(l) - 5 >= K) {
l++;
}
sum += r - l;
}
System.out.println(sum);
sc.close();
}
private static boolean check(char ch) {
// TODO Auto-generated method stub
return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
}
}
試題 I: 后綴運算式
試題 I: 后綴運算式
時間限制: 1.0s 記憶體限制: 512.0MB 本題總分：25 分
【問題描述】
給定 N 個加號、M 個減號以及 N + M + 1 個整數 A1, A2, · · · , AN+M+1，小明想知道在所有由這 N 個加號、M 個減號以及 N + M + 1 個整數湊出的合法的
后綴運算式中，結果最大的是哪一個？
請你輸出這個最大的結果，
例如使用1 2 3 + -，則 “2 3 + 1 -” 這個后綴運算式結果是 4，是最大的，
【輸入格式】
第一行包含兩個整數 N 和 M，
第二行包含 N + M + 1 個整數 A1, A2, · · · , AN+M+1，
【輸出格式】
輸出一個整數，代表答案，
【樣例輸入】
1 1
1 2 3
【樣例輸出】
4
【評測用例規模與約定】
對于所有評測用例，0 ≤ N, M ≤ 100000，?109 ≤ Ai ≤ 109，
試題決議:
將可能組合最大情況進行分析,后綴運算式中可以加括號和兩個減號.
(此代碼并非最優代碼,但所有測驗資料都能通過)
代碼:
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int add = sc.nextInt();
int reduce = sc.nextInt();
int t = add + reduce + 1;
int[] number = new int[t];
for (int i = 0; i < t; i++) {
number[i] = sc.nextInt();
}
long sum = 0;
if (reduce == 0 && add == 0) {
sum += number[0];
}
if (reduce == 0 && add != 0) {
for (int i = 0; i < t; i++) {
sum += number[i];
}
}
if (add == 0 && reduce != 0) {
Arrays.sort(number);
if (number[0] < 0) {
for (int i = 0; i <= reduce; i++) {
if (number[i] > 0) {
sum += number[i];
} else {
sum -= number[i];
}
}
} else {
for (int i = 1; i <= reduce; i++) {
sum += number[i];
}
sum -= number[0];
}
}
if (add != 0 && reduce != 0) {
int reduceNum = 0;
for (int i = 0; i < t; i++) {
if (number[i] < 0) {
reduceNum++;
}
}
if (reduce >= reduceNum) {
if (reduceNum != 0) {
Arrays.sort(number);
for (int i = 0; i < reduceNum; i++) {
number[i] = -number[i];
}
// Arrays.sort(number);
for (int i = t - 1; i >= 0; i--) {
sum += number[i];
}
}else {
Arrays.sort(number);
for (int i = t - 1; i > 0; i--) {
sum += number[i];
}
sum -= number[0];
}
} else {
Arrays.sort(number);
sum += number[t - 1];
for (int i = 0; i < t - 1; i++) {
if (number[i] > 0) {
sum += number[i];
} else {
sum -= number[i];
}
}
}
}
System.out.println(sum);
sc.close();
}
}
試題 J: 靈能傳輸
試題 J: 靈能傳輸
時間限制: 5.0s 記憶體限制: 512.0MB 本題總分：25 分
【題目背景】
在游戲《星際爭霸 II》中，高階圣堂武士作為星靈的重要 AOE 單位，在游戲的中后期發揮著重要的作用，其技能”靈能風暴“可以消耗大量的靈能對一片區域內的敵軍造成毀滅性的傷害，經常用于對抗人類的生化部隊和蟲族的刺蛇飛龍等低血量單位，
【問題描述】
你控制著 n 名高階圣堂武士，方便起見標為 1, 2, · · · , n，每名高階圣堂武士需要一定的靈能來戰斗，每個人有一個靈能值 ai 表示其擁有的靈能的多少（ai非負表示這名高階圣堂武士比在最佳狀態下多余了 ai 點靈能，ai 為負則表示這名高階圣堂武士還需要 ?ai 點靈能才能到達最佳戰斗狀態），現在系統賦予了你的高階圣堂武士一個能力，傳遞靈能，每次你可以選擇一個 i ∈ [2, n ? 1]，若ai ≥ 0 則其兩旁的高階圣堂武士，也就是 i ? 1、i + 1 這兩名高階圣堂武士會從i 這名高階圣堂武士這里各抽取 ai 點靈能；若 ai < 0 則其兩旁的高階圣堂武士，也就是 i ? 1, i + 1 這兩名高階圣堂武士會給 i 這名高階圣堂武士 ?ai 點靈能，形式化來講就是 ai?1+ = ai, ai+1+ = ai, ai? = 2ai，靈能是非常高效的作戰工具，同時也非常危險且不穩定，一位高階圣堂武士擁有的靈能過多或者過少都不好，定義一組高階圣堂武士的不穩定度為maxni=1|ai|，請你通過不限次數的傳遞靈能操作使得你控制的這一組高階圣堂武士的不穩定度最小，
【輸入格式】
本題包含多組詢問，輸入的第一行包含一個正整數 T 表示詢問組數，接下來依次輸入每一組詢問，每組詢問的第一行包含一個正整數 n，表示高階圣堂武士的數量，接下來一行包含 n 個數 a1, a2, · · · , an，
【輸出格式】
輸出 T 行，每行一個整數依次表示每組詢問的答案，
【樣例輸入】
3
3
5 -2 3
4
0 0 0 0
3
1 2 3
【樣例輸出】
3
0
3
【樣例說明】
對于第一組詢問：
對 2 號高階圣堂武士進行傳輸操作后 a1 = 3，a2 = 2，a3 = 1，答案為 3，
對于第二組詢問：
這一組高階圣堂武士擁有的靈能都正好可以讓他們達到最佳戰斗狀態，
【樣例輸入】
3
4
-1 -2 -3 7
4
2 3 4 -8
5
-1 -1 6 -1 -1
【樣例輸出】
5
7
4
【樣例輸入】
見檔案trans3.in，
【樣例輸出】
見檔案trans3.ans，
【資料規模與約定】
對于所有評測用例，T ≤ 3，3 ≤ n ≤ 300000，|ai
| ≤ 109，
評測時將使用 25 個評測用例測驗你的程式，每個評測用例的限制如下：
評測用例編號 n |ai
| 特殊性質
1 = 3 ≤ 1000 無
2,3 ≤ 5 ≤ 1000 無
4,5,6,7 ≤ 10 ≤ 1000 無
8,9,10 ≤ 20 ≤ 1000 無
11 ≤ 100 ≤ 109 所有 ai 非負
12,13,14 ≤ 100 ≤ 109 無
15,16 ≤ 500 ≤ 109 無
17,18,19 ≤ 5000 ≤ 109 無
20 ≤ 5000 ≤ 109 所有 ai 非負
21 ≤ 100000 ≤ 109 所有 ai 非負
22,23 ≤ 100000 ≤ 109 無
24,25 ≤ 300000 ≤ 109 無
注意：本題輸入量較大請使用快速的讀入方式，
代碼:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
//import java.util.Scanner;
public class Main {
private static long[] a;
private static long[] s;
private static boolean[] st;
private static int n;
public static void main(String[] args) throws NumberFormatException, IOException {
int T;
//Scanner sc = new Scanner(System.in);
BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
//T = sc.nextInt();
T = Integer.parseInt(sc.readLine().trim());
while(T-- > 0) {
//n = sc.nextInt();
n = Integer.parseInt(sc.readLine().trim());
String[] arr = sc.readLine().trim().split(" ");
a = new long[n + 1];
s = new long[n + 1];
st = new boolean[n + 1];
s[0] = 0;
for(int i = 1; i <= n; i++) {
//s[i] = sc.nextLong();
s[i] = Integer.parseInt(arr[i - 1]);
s[i] += s[i - 1];
}
long s0 = s[0], sn = s[n];
if(s0 > sn) {
long temp = s0;
s0 = sn;
sn = temp;
}
Arrays.sort(s);
for(int i = 0; i <= n; i++) {
if(s[i] == s0) {
s0 = i;
break;
}
}
for (int i = n; i >= 0; i--) {
if(s[i] == sn) {
sn = i;
break;
}
}
int l = 0, r = n;
for(int i = (int)s0; i >= 0; i -= 2) {
a[l++] = s[i];
st[i] = true;
}
for(int i = (int)sn; i <= n; i += 2) {
a[r--] = s[i];
st[i] = true;
}
for(int i = 0; i <= n; i++) {
if(!st[i]) {
a[l++] = s[i];
}
}
long res = 0;
for(int i = 1; i <= n; i++) {
if(Math.abs(a[i] - a[i - 1]) > res) {
res = Math.abs(a[i] - a[i - 1]);
}
}
System.out.println(res);
}
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/248981.html
標籤：其他
上一篇：2021，JuiceFS 開源啦
下一篇：用撲克游戲操練List常用方法