相關試題：
2019年第十屆藍橋杯真題決議 JAVAC組
A：組隊
題目描述
作為籃球隊教練，你需要從以下名單中選出 1 號位至 5 號位各一名球員， 組成球隊的首發陣容，
每位球員擔任 1 號位至 5 號位時的評分如下表所示，請你計算首發陣容 1 號位至 5 號位的評分之和最大可能是多少？
如果你把以上文字復制到文本檔案中，請務必檢查復制的內容是否與文 檔中的一致，在試題目錄下有一個檔案 team.txt，內容與上面表格中的相同， 請注意第一列是編號
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一 個整數，在提交答案時只填寫這個整數，填寫多余的內容將無法得分，
思路：
這題就是送分題，直接暴力或者按表格數就行了，暴力就相當
于，五個位置，20個人爭奪，使其總和最大，但一個人只能出
現在一個位置上；
答案：490
第二題：不同子串
題目描述
一個字串的非空子串是指字串中長度至少為 1 的連續的一段字符組成 的串，例如，字串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 個， 注意在計算時，只算本質不同的串的個數，
請問，字串0100110001010001 有多少個不同的非空子串？
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一 個整數，在提交答案時只填寫這個整數，填寫多余的內容將無法得分，
思路：
先考慮所有的情況，再考慮去重；
1.所有情況：就是一個雙重回圈，以第一個數為開頭的所有可能，
以第二個數為開頭的所有可能.......;
2.去重：Java中Set集合可以去重；
代碼：
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class 不同子串B {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
String arr=input.next();
Set<String > set=new HashSet<String>();
for(int i=0;i<arr.length();i++){
//以i為開頭的所有可能結果所以j必須大于i
for(int j=i+1;j<=arr.length();j++){
//雖然substring 下標i~j的時候是不包含j的
//每個數字開頭本身也是個非空子串，也符合題意
//所以不需要變成substring(i,j+1)，
//由于需要包含到最后一個字符所以j最大值為arr,length();
String temp=arr.substring(i,j);
set.add(temp);
}
}
System.out.println(set.size());
}
}
答案：100
第三題：數列求值
題目描述
給定數列 1, 1, 1, 3, 5, 9, 17, …，從第 4 項開始，每項都是前 3 項的和，求 第 20190324 項的最后 4 位數字，
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一 個 4 位整數（提示：答案的千位不為 0），在提交答案時只填寫這個整數，填寫 多余的內容將無法得分，
思路：
這個題感覺就是三位數的斐波那契數列，注意爆Int
代碼：
import java.util.Scanner;
public class 數列求值 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
long a=1;
long b=1;
long c=1;
//試了一下long也能爆，還是取摸吧
//前面三項已經有了，從第四項開始
for(int i=4;i<=20190324;i++){
long temp=((a+b+c)%10000);
a=b;
b=c;//依次往后移
c=temp;
}
System.out.println(c);
}
}
答案：4659
第四題：數的分解
題目描述
把 2019 分解成 3 個各不相同的正整數之和，并且要求每個正整數都不包 含數字 2 和 4，一共有多少種不同的分解方法？
注意交換 3 個整數的順序被視為同一種方法，例如 1000+1001+18 和 1001+1000+18 被視為同一種，
【答案提交】
這是一道結果填空的題，你只需要算出結果后提交即可，本題的結果為一 個整數，在提交答案時只填寫這個整數，填寫多余的內容將無法得分，
思路：
這里可以直接暴力做由于有重復的，在回圈的時候要改一下，
我是把所有的數字強轉成String型別，然后用contains方法
來看是否包含2或4；
代碼：
public class 數的分解D {
public static void main(String[] args) {
int a=2019;
int ans=0;//存結果
for(int i=1;i<=2019;i++){
String tempi=i+"";
if(tempi.contains("2")||tempi.contains("4"))
continue;
for(int j=i+1;j<=2019;j++){
String tempj=j+"";
if(tempj.contains("2")||tempj.contains("4"))
continue;
for(int k=j+1;k<=2019;k++){
String tempk=k+"";
if(tempk.contains("2")||tempk.contains("4"))
continue;
if(i+j+k==a)
ans++;
}
}
}
System.out.println(ans);
}
}
答案：40785
第五題：迷宮
題目描述
下圖給出了一個迷宮的平面圖，其中標記為 1 的為障礙，標記為 0 的為可 以通行的地方，
010000 000100 001001 110000
迷宮的入口為左上角，出口為右下角，在迷宮中，只能從一個位置走到這 個它的上、下、左、右四個方向之一，
對于上面的迷宮，從入口開始，可以按DRRURRDDDR 的順序通過迷宮， 一共 10 步，其中 D、U、L、R 分別表示向下、向上、向左、向右走，
對于下面這個更復雜的迷宮（30 行 50 列），請找出一種通過迷宮的方式， 其使用的步數最少，在步數最少的前提下，請找出字典序最小的一個作為答案， 請注意，（如果你把以下文字復制到文本檔案中，請務 必檢查復制的內容是否與檔案中的一致，在試題目錄下有一個檔案 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，在提交答案時只填寫這個字串，填 寫多余的內容將無法得分，
思路：
1.看到步數最少我就想到了BFS,題目中說“在字典序中D<L<R<U”，所以
我們在BFS的時候順序就定為D L R U，正好就符合題意；
2.套路就是常用的BFS，一般的題求的都是最后一個點得最小步數，這個
求路徑且字典序最小，我們就需要一個二維陣列來存到每個點的最小步數
最小字典序的路徑，代碼中有注釋，這題跟“馬的遍歷”差不多，感興趣的
可以看一下，都是基礎的BFS；
馬的遍歷
代碼：
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class E迷宮 {
static int []xx={0,1,0,0,-1};
static int []yy={0,0,-1,1,0};
public static void main(String arr[]){
Scanner input=new Scanner (System.in);
int N=30;
String []map=new String[N+1];
//生成地圖
for(int i=0;i<N;i++){
map[i]=input.next();
}
char [][]arrmap=new char[N+1][N+1];
for(int i=0;i<N;i++){
arrmap[i]=map[i].toCharArray();
}
int M=arrmap[0].length;
String [][]res=new String [N+1][M+1];
//初始化到達每個點的路徑，不然會有問題，答案會帶一個null
for(int i=0;i<N;i++){
for(int j=0;j<M;j++){
res[i][j]="";
}
}
int [][]tempmap=new int[N+1][M+1];//來看每個是否已經遍歷過
int startx=0;//起點
int starty=0;
//初始化佇列
tempmap[startx][starty]=1;
Queue <Integer> abscissa=new LinkedList<Integer>();
Queue <Integer> vertical=new LinkedList<Integer>();
abscissa.offer(startx);
vertical.offer(starty);
while(!abscissa.isEmpty()&&!vertical.isEmpty()){
int motherx=abscissa.poll();
int mothery=vertical.poll();
// 遍歷四個方向 D L R U
for(int i=1;i<=4;i++){
int tempx=motherx+xx[i];
int tempy=mothery+yy[i];
//是否越界
if(tempx>=N||tempx<0)
continue;
if(tempy>=M||tempy<0)
continue;
//是否能走
if(arrmap[tempx][tempy]!='0'){
continue;
}
//是否走過
if(tempmap[tempx][tempy]==1)
continue;
//保存答案 ，記錄下一個節點
else{
//看走到這個結點對應的方向
String tempans="";
if(i==1)
tempans="D";
if(i==2)
tempans="L";
if(i==3)
tempans="R";
if(i==4)
tempans="U";
//走到這個結點的上一結點就是motherx和mothery
//只需把上個結點的路徑加上，上個結點走到這個結點
//的方向就是這個結點的路徑；
res[tempx][tempy]=(res[motherx][mothery]+tempans);
abscissa.offer(tempx);
vertical.offer(tempy);
tempmap[tempx][tempy]=1;
}
}
}
System.out.print(res[N-1][M-1]);
}
}
答案：
DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
第六題：特別數的和
題目描述
小明對數位中含有 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，
時間限制：1.0s
記憶體限制：512.0MB
思路：
這題我跟上面一樣用的強轉，由于沒有專業測驗樣例我也不知道
會不會超時報錯，我覺得應該不會，就一重回圈不至于
代碼：
import java.util.Scanner;
public class 特別數的和F {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int n=input.nextInt();
long sum=0;
for(int i=1;i<=n;i++){
String temp=i+"";
if(temp.contains("2")||temp.contains("0")||temp.contains("1")||temp.contains("9"))
sum+=i;
}
System.out.println(sum);
}
}
第七題：外賣店優先級
題目描述
“飽了么”外賣系統中維護著 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，
時間限制：1.0s
記憶體限制：512.0MB
這題我以前寫過一個得百分之80混分版的，滿分的實屬沒寫來，
這篇混分版題解里有滿分的鏈接在最后面，acwing里的小伙伴寫的
藍橋杯 外賣店的優先級 Java 易懂版 （80%得分考試混分版）
代碼：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int N=input.nextInt();
int M=input.nextInt();
int T=input.nextInt();
List arr[]=new ArrayList[T+1];
int better[]=new int[N+1];
boolean level[]=new boolean[N+1];
for(int i=0;i<=T;i++){
arr[i]=new ArrayList();
}
for(int i=1;i<=M;i++){
int ts=input.nextInt();
int id=input.nextInt();
arr[ts].add(id); //t時刻有店鋪id的訂單，
}
for(int i=1;i<=T;i++){
for(int j=1;j<=N;j++){
int flag=0;
Object k=j;
while (arr[i].contains(k)){
flag=1;
better[j]+=2;
arr[i].remove(k);
if(better[j]>5)
level[j]=true;
}
if(flag==0) { //此時刻無店鋪j的訂單
better[j] = better[j] == 0 ? 0 : better[j] - 1;
if (level[j]) { //原來在快取佇列
if (better[j] <= 3) { //優先級下降
level[j] = false;
}
}
}
}
}
int count=0;
for(int i=1;i<=N;i++){
if(level[i])
count++;
}
System.out.println(count);
}
}
第八題：人物相關性分析
題目描述
小明正在分析一本小說中的人物相關性，他想知道在小說中 Alice 和 Bob 有多少次同時出現，
更準確的說，小明定義 Alice 和 Bob“同時出現”的意思是：在小說文本 中 Alice 和 Bob 之間不超過 K 個字符，
例如以下文本：
20 This is a story about Alice and Bob.Alice wants
to send aprivate 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 aprivate message to Bob.
【樣例輸出】
2
【評測用例規模與約定】
對于所有評測用例，1≤ K ≤1000000，
時間限制：1.0s
記憶體限制：512.0MB
思路:
1.這題比較困擾我的是這里一個“.”，“，”表示兩個字符，但分割后我咋知
道有多少個點被算進去了， 別人的一種方法： str.split("\\s+|\\.")，
我覺得這樣是有問題的，按照上面的方法 舉個例子：
輸入：This is a story about Alice.and.Bob.Alice wants to send aprivate message to Bob.
輸出：This is a story about Alice and Bob Alice wants to send aprivate message to Bob
這樣子Alice.and.Bob的距離是7，但在實際運算的時候我們并不知道中間會
有多少個字符，在我絞盡腦汁下，在網上看到這樣一個方法很巧妙這是鏈接
https://www.jianshu.com/p/7342d800efa2；
2：大致思路是這樣把所有的.變成“ab”，然后再按空格拆分，這個時候
Bob.Alice會變成Bob ab Alice這個時候計算長度的時候就要注意，具體
看代碼；
3.Alice和Bob的前后順序沒關系，只要距離小于K就行了，因此需要找兩邊，
確定Alice后找Bob 和確定Bob后找Alice；
4.三重回圈可能會超時，沒有測驗用例我也不清楚，因此用兩重保險點，
三重是先確定Alice 然后再確定Bob，然后再用一個回圈計算兩者的長度
我們一遍找Bob一邊記錄長度，如果最后找的Bob符合要答案加1，不符合
根據判斷條件無法更新答案，這樣應該能優化點時間；
代碼：
import java.util.Scanner;
public class 人物相關性格分析H {
public static void main(String[] args) {
Scanner reader=new Scanner(System.in);
int res=0; //save result
int K=reader.nextInt();
reader.nextLine(); //nextLine吸取回車鍵
String str=reader.nextLine();
str=str.replaceAll("\\.", " ab ");
String []arr=str.split("\\s+");
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
int ans=0;//保存答案
//找每個Alice 后面有多少個合適的Bob
for(int i=0;i<arr.length;i++){
//找匹配的Alice
if(arr[i].equals("Alice")||arr[i].equals("Aliceab")){
int distance=1;//Alice 后面要是有單詞肯定會有一個空格除非是最后一個數，最后一個數就不用考慮了
for(int j=i+1;j<arr.length;j++){
//找合適的Bob
if((arr[j].equals("Bob")||arr[j].equals("Bobab"))&&distance<=K){
ans++;
}
//沒有就把這段距離加上免得用三重回圈
else{
//Bob.Alice 會轉化為 Bob ab Alice
//原本的長度是2轉變后為4，因為會多兩個空格
//所以當arr[j]為ab是不要加空格的長度，還要減去之前Bob后面的空格
if(arr[j].equals("ab")) {
distance += arr[j].length();
distance-=1;
}
else
distance+=arr[j].length()+1;
}
}
}
}
//找每個Bob后面有多少個符合的Alice
for(int i=0;i<arr.length;i++){
//找匹配的Alice
if(arr[i].equals("Bob")||arr[i].equals("Bobab")){
int distance=1;//Bob 后面要是有單詞肯定會有一個空格
for(int j=i+1;j<arr.length;j++){
//找合適的Alice
if((arr[j].equals("Alice")||arr[j].equals("Alice"))&&distance<=K){
ans++;
}
//沒有就把這段距離加上免得用三重回圈
else{
//Bob.Alice 會轉化為 Bob ab Alice
//原本的長度是2轉變后為4，因為會多兩個空格
//所以當arr[j]為ab是不要加空格的長度，還要減去之前Bob后面的空格
if(arr[j].equals("ab")) {
distance += arr[j].length();
distance-=1;
}
else
distance+=arr[j].length()+1;
}
}
}
}
System.out.println(ans);
}
}
第九題：后綴運算式
題目描述
給定 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，
時間限制：1.0s
記憶體限制：512.0MB
思路：
這是一道貪心題由上面的例子我們可以推斷M個“-”可以變成一個“-”，
這樣就簡單了，先給陣列排個序，把出最小值外的數全部相加，然后
再減去最小值就是答案，這個思路來自Y總，Y總牛逼！
代碼：
import java.util.Arrays;
import java.util.Scanner;
public class 后綴運算式 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int N = input.nextInt();
int M = input.nextInt();
int arr[] = new int[N + M + 1];
for (int i = 0; i < N + M + 1; i++) {
arr[i] = input.nextInt();
}
Arrays.sort(arr);
long res=0;
if(M==0){
for(int i=0;i<=arr.length-1;i++)
res+=arr[i];
}
else{
int Max=arr[arr.length-1];
int Min=arr[0];
res+=Max;
res-=Min;
for(int i=1;i<arr.length-1;i++)
res+=Math.abs(arr[i]);
}
System.out.println(res);
}
}
第十題：靈能傳輸
題目描述
【題目背景】
在游戲《星際爭霸 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，
靈能是非常高效的作戰工具，同時也非常危險且不穩定，一位高階圣堂 武士擁有的靈能過多或者過少都不好，定義一組高階圣堂武士的不穩定度為 maxn i=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 個評測用例測驗你的程式，每個評測用例的限制如下：
注意：本題輸入量較大請使用快速的讀入方式，
時間限制：5.0s
記憶體限制：512.0MB
這個題有點難，不大適合我，這里有解法ACWING
有些題沒有辦法測驗其他案例，如果有錯誤的地方，請大佬指出，不勝感激，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/98739.html
標籤：python