2017年第08届蓝桥杯 Java B组决赛真题详解及小结

布满荆棘的人生 2022-12-19 00:55 261阅读 0赞

>  *  [蓝桥杯 Java B组 省赛决赛 真题详解及小结汇总【2013年(第4届)~2020年(第11届)】][Java B_ _ _2013_4_2020_11]
>  *  [第11届 蓝桥杯-第1、2次模拟(软件类)真题-(2020年3月、4月)-官方讲解视频][11_ _-_1_2_-_2020_3_4_-]
> 
> --------------------
> 
>  *  说明：大部分题解思路及程序代码 源自 [蓝桥杯 官网视频(Java B组历年真题解析)][_Java B] —— [郑未老师][Link 1]。
> 
> 1.  [2013年 第04届 蓝桥杯 Java B组 省赛真题详解及小结][2013_ _04_ _ Java B_]
> 2.  [2014年 第05届 蓝桥杯 Java B组 省赛真题详解及小结][2014_ _05_ _ Java B_]
> 3.  [2015年 第06届 蓝桥杯 Java B组 省赛真题详解及小结][2015_ _06_ _ Java B_]
> 4.  [2016年 第07届 蓝桥杯 Java B组 省赛真题详解及小结][2016_ _07_ _ Java B_]
> 5.  [2017年 第08届 蓝桥杯 Java B组 省赛真题详解及小结][2017_ _08_ _ Java B_]
> 6.  [2018年 第09届 蓝桥杯 Java B组 省赛真题详解及小结][2018_ _09_ _ Java B_]
> 7.  [2019年 第10届 蓝桥杯 Java B组 省赛真题详解及小结][2019_10_ _ Java B_]
> 8.  [2020年 第11届 蓝桥杯 第1次模拟赛真题详解及小结【Java版】（校内模拟）][2020_11_ _ _1_Java]// [官方讲解视频][11_ _-_1_2_-_2020_3_4_-]
> 9.  [2020年 第11届 蓝桥杯 第2次模拟赛真题详解及小结【Java版】][2020_11_ _ _2_Java]// [官方讲解视频][11_ _-_1_2_-_2020_3_4_-]
> 10. [2020年 第11届 蓝桥杯 C/C++ B组 省赛真题详解及小结【第1场省赛 2020.07.05】][2020_11_ _ C_C_ B_ _1_ 2020.07.05][【Java版】][2020_11_ _ C_C_ B_ _1_ 2020.07.05]
> 11. [2020年 第11届 蓝桥杯 Java B组 省赛真题详解及小结【第1场省赛 2020.07.05】][2020_11_ _ Java B_ _1_ 2020.07.05]
> 12. [2020年 第11届 蓝桥杯 Java B组 省赛真题详解及小结【第2场省赛 2020.10.17】][2020_ _11_ _ Java B_ _2_ 2020.10.17]
> 13. [2020年 第11届 蓝桥杯 Java C组 省赛真题详解及小结【第1场省赛 2020.07.05】][2020_11_ _ Java C_ _1_ 2020.07.05]
> 
> --------------------
> 
> 1.  2015年 第06届 蓝桥杯 Java B组 决赛真题详解及小结
> 2.  2016年 第07届 蓝桥杯 Java B组 决赛真题详解及小结
> 3.  2017年 第08届 蓝桥杯 Java B组 决赛真题详解及小结
> 4.  2018年 第09届 蓝桥杯 Java B组 决赛真题详解及小结
> 5.  2019年 第10届 蓝桥杯 Java B组 决赛真题详解及小结
> 6.  2020年 第11届 蓝桥杯 Java B组 决赛真题详解及小结

***目   录***

一、平方十位数（结果填空 满分17分）——答案：

二、生命游戏（结果填空 满分45分）——答案：

三、树形显示（代码填空 满分23分）——答案：

四、小计算器（程序设计 满分43分）

五、填字母游戏（程序设计 满分71分）

六、区间移位（程序设计 满分101分）

小结

--------------------

> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70][]
> 
> ![20201110193819782.png][]   ![20201110193712411.png][]

# 一、平方十位数（结果填空 满分17分）——答案：9814072356 #

> 标题：平方十位数
> 
> 由0~9这10个数字不重复、不遗漏，可以组成很多10位数字。  
> 这其中也有很多恰好是平方数（是某个数的平方）。
> 
> 比如：1026753849，就是其中最小的一个平方数。
> 
> 请你找出其中最大的一个平方数是多少？
> 
> 注意：你需要提交的是一个10位数字，不要填写任何多余内容。

## 解法一 ##

> ![20201110194109800.png][]
> 
> ![20201110193420160.png][]

package national_08_2017;
    
    public class A01_平方十位数 {
    
    	public static long max = 0;
    
    	public static void main(String[] args) {
    //		System.out.println(Integer.MAX_VALUE);
    		int a[] = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    		f(a, 0);
    		System.out.println(max);
    	}
    
    	public static void f(int arr[], int k) { // 全排列 列出0~9的全部组合
    		if (k == arr.length) {
    //			System.out.println(Arrays.toString(arr));
    			check(arr);
    			return;
    		}
    		for (int i = k; i < arr.length; i++) {
    			int temp = arr[i];
    			arr[i] = arr[k];
    			arr[k] = temp;
    			f(arr, k + 1);
    			temp = arr[i];
    			arr[i] = arr[k];
    			arr[k] = temp;
    		}
    	}
    
    	public static void check(int[] arr) {
    //		String temp = "";
    //		for (int i = 0; i < arr.length; i++) {
    //			temp += arr[i];
    //		}
    //		long sum = Integer.parseInt(temp);
    //		System.out.println(sum);
    		for (long i = (long) Math.sqrt(sum) - 1; i <= (long) Math.sqrt(sum) + 1; i++) {
    			if (i * i == sum) {
    				System.out.println(sum);
    				max = Math.max(max, sum);
    				break;
    			}
    		}
    //		int x = (int) Math.sqrt(sum);
    //		if (x * x == sum) {
    //			max = Math.max(max, sum);
    //		}
    		long t = 0;
    		for (int i = 0; i < 10; i++) {
    			t *= 10;
    			t += arr[i];
    		}
    		long x = (long) Math.sqrt(t);
    		if (x * x == t) {
    			max = Math.max(max, t);
    		}
    	}
    
    }

## 解法二 ##

> [原文链接——wyk][wyk]
> 
> ![20201110194152627.png][]
> 
> ![20201110193247320.png][]

package national_08_2017;
    
    public class A01_平方十位数2 {
    
    	public static long ans = 0;
    	public static int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    
    	public static void tolong() {
    		long t = 0;
    		for (int i = 0; i < 10; i++) {
    			t *= 10;
    			t += arr[i];
    		}
    		long x = (long) Math.sqrt(t);
    		if (x * x == t) {
    			ans = Math.max(ans, t);
    		}
    	}
    
    	public static void qpl(int k) {
    		if (k >= arr.length)
    			tolong();
    		else {
    			for (int i = k; i < arr.length; i++) {
    				int t = arr[i];
    				arr[i] = arr[k];
    				arr[k] = t;
    				qpl(k + 1);
    				t = arr[i];
    				arr[i] = arr[k];
    				arr[k] = t;
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		qpl(0);
    		System.out.println(ans);
    	}
    
    }

# 二、生命游戏（结果填空 满分45分）——答案： #

> 标题：生命游戏
> 
> 康威生命游戏是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。    
> 这个游戏在一个无限大的2D网格上进行。
> 
> 初始时，每个小方格中居住着一个活着或死了的细胞。  
> 下一时刻每个细胞的状态都由它周围八个格子的细胞状态决定。
> 
> 具体来说：
> 
> 1. 当前细胞为存活状态时，当周围低于2个（不包含2个）存活细胞时， 该细胞变成死亡状态。（模拟生命数量稀少）  
> 2. 当前细胞为存活状态时，当周围有2个或3个存活细胞时， 该细胞保持原样。  
> 3. 当前细胞为存活状态时，当周围有3个以上的存活细胞时，该细胞变成死亡状态。（模拟生命数量过多）  
> 4. 当前细胞为死亡状态时，当周围有3个存活细胞时，该细胞变成存活状态。 （模拟繁殖）
> 
> 当前代所有细胞同时被以上规则处理后, 可以得到下一代细胞图。按规则继续处理这一代的细胞图，可以得到再下一代的细胞图，周而复始。
> 
> 例如假设初始是:(X代表活细胞，.代表死细胞)  
> .....  
> .....  
> .XXX.  
> .....
> 
> 下一代会变为:  
> .....  
> ..X..  
> ..X..  
> ..X..  
> .....
> 
> 康威生命游戏中会出现一些有趣的模式。例如稳定不变的模式：
> 
> ....  
> .XX.  
> .XX.  
> ....
> 
> 还有会循环的模式：
> 
> ......      ......       ......  
> .XX...      .XX...       .XX...  
> .XX...      .X....       .XX...  
> ...XX.   -> ....X.  ->   ...XX.  
> ...XX.      ...XX.       ...XX.  
> ......      ......       ......
> 
>   
> 本题中我们要讨论的是一个非常特殊的模式，被称作"Gosper glider gun"：
> 
> ......................................  
> .........................X............  
> .......................X.X............  
> .............XX......XX............XX.  
> ............X...X....XX............XX.  
> .XX........X.....X...XX...............  
> .XX........X...X.XX....X.X............  
> ...........X.....X.......X............  
> ............X...X.....................  
> .............XX.......................  
> ......................................
> 
> 假设以上初始状态是第0代，请问第1000000000(十亿)代一共有多少活着的细胞？
> 
> 注意：我们假定细胞机在无限的2D网格上推演，并非只有题目中画出的那点空间。  
> 当然，对于遥远的位置，其初始状态一概为死细胞。
> 
> 注意：需要提交的是一个整数，不要填写多余内容。

# 三、树形显示（代码填空 满分23分）——答案： #

> 标题：树形显示
> 
> 对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。
> 
> 树中的结点具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。
> 
> 下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。
> 
>   
> import java.util.\*;
> 
> class MyTree  
> \{  
>     private Map<String, List<String>>  map\_ch = new HashMap<String, List<String>>();  
>     private Map<String,String> map\_pa = new HashMap<String,String>();  
>       
>     public void add(String parent, String child)  
>     \{  
>         map\_pa.put(child, parent);  
>           
>         List<String> lst = map\_ch.get(parent);  
>         if(lst==null)\{  
>             lst = new ArrayList<String>();  
>             map\_ch.put(parent, lst);  
>         \}  
>         lst.add(child);  
>     \}  
>       
>     public String get\_parent(String me)\{  
>         return map\_pa.get(me);  
>     \}  
>       
>     public List<String> get\_child(String me)\{  
>         return map\_ch.get(me);  
>     \}  
>       
>     private String space(int n)  
>     \{  
>         String s = "";  
>         for(int i=0; i<n; i++) s += ' ';  
>         return s;  
>     \}  
>       
>     private boolean last\_child(String x)\{  
>         String pa = map\_pa.get(x);  
>         if(pa==null) return true;  
>           
>         List<String> lst = map\_ch.get(pa);  
>         return lst.get(lst.size()-1).equals(x);  
>     \}  
>       
>     public void show(String x)\{  
>           
>         String s = "+--" + x;  
>           
>         String pa = x;  
>         while(true)\{  
>             pa = map\_pa.get(pa);  
>             if(pa==null) break;  
>             s = \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ ;  // 填空  
>         \}  
>           
>         System.out.println(s);  
>     \}  
>       
>     public void dfs(String x)\{  
>         show(x);  
>           
>         List<String> lst = map\_ch.get(x);  
>         if(lst==null) return;  
>                   
>         for(String it: lst)\{  
>             dfs(it);  
>         \}  
>     \}  
> \}
> 
> public class TreeView  
> \{  
>     public static void main(String\[\] args)  
>     \{  
>         MyTree tree = new MyTree();  
>         tree.add("root", "dog");  
>         tree.add("root", "cat");  
>         tree.add("root", "duck");  
>         tree.add("dog", "AAdog");  
>         tree.add("dog", "BBdog");  
>         tree.add("dog", "CCdog");  
>         tree.add("AAdog", "AAdog01");  
>         tree.add("AAdog", "AAdog02");  
>         tree.add("cat", "XXcat");  
>         tree.add("cat", "YYcat");  
>         tree.add("XXcat","XXcat-oo");  
>         tree.add("XXcat","XXcat-qq");  
>         tree.add("XXcat-qq", "XXcat-qq-hahah");  
>         tree.add("duck", "TTduck");  
>         tree.add("TTduck", "TTduck-001");  
>         tree.add("TTduck", "TTduck-002");  
>         tree.add("TTduck", "TTduck-003");  
>         tree.add("YYcat","YYcat.hello");  
>         tree.add("YYcat","YYcat.yes");  
>         tree.add("YYcat","YYcat.me");          
>           
>         tree.dfs("root");  
>     \}  
> \}
> 
> 对于题目中的测试数据，输出结果:  
> \+--root  
>      +--dog  
>      |    +--AAdog  
>      |    |    +--AAdog01  
>      |    |    +--AAdog02  
>      |    +--BBdog  
>      |    +--CCdog  
>      +--cat  
>      |    +--XXcat  
>      |    |    +--XXcat-oo  
>      |    |    +--XXcat-qq  
>      |    |         +--XXcat-qq-hahah  
>      |    +--YYcat  
>      |         +--YYcat.hello  
>      |         +--YYcat.yes  
>      |         +--YYcat.me  
>      +--duck  
>           +--TTduck  
>                +--TTduck-001  
>                +--TTduck-002  
>                +--TTduck-003  
>                  
> 如有平字体对齐问题，可以参见图【p1.png】
> 
> 注意，只填写划线部分缺少的代码，不要抄写已有的代码或符号。
> 
> ![20201108220510614.png][] p1.png

# 四、小计算器（程序设计 满分43分） #

> 标题：小计算器
> 
> 模拟程序型计算器，依次输入指令，可能包含的指令有
> 
> 1. 数字：'NUM X'，X为一个只包含大写字母和数字的字符串，表示一个当前进制的数  
> 2. 运算指令：'ADD','SUB','MUL','DIV','MOD'，分别表示加减乘，除法取商，除法取余  
> 3. 进制转换指令：'CHANGE K'，将当前进制转换为K进制(2≤K≤36)  
> 4. 输出指令：'EQUAL'，以当前进制输出结果  
> 5. 重置指令：'CLEAR'，清除当前数字
> 
> 指令按照以下规则给出：  
> 数字，运算指令不会连续给出，进制转换指令，输出指令，重置指令有可能连续给出  
> 运算指令后出现的第一个数字，表示参与运算的数字。且在该运算指令和该数字中间不会出现运算指令和输出指令  
> 重置指令后出现的第一个数字，表示基础值。且在重置指令和第一个数字中间不会出现运算指令和输出指令  
> 进制转换指令可能出现在任何地方
> 
> 运算过程中中间变量均为非负整数，且小于2^63。  
> 以大写的'A'~'Z'表示10~35
> 
> \[输入格式\]  
> 第1行：1个n，表示指令数量  
> 第2..n+1行：每行给出一条指令。指令序列一定以'CLEAR'作为开始，并且满足指令规则
> 
> \[输出格式\]  
> 依次给出每一次'EQUAL'得到的结果
> 
> \[样例输入\]  
> 7  
> CLEAR  
> NUM 1024  
> CHANGE 2  
> ADD  
> NUM 100000  
> CHANGE 8  
> EQUAL
> 
> \[样例输出\]  
> 2040
> 
> 补充说明：  
> 1. n 值范围: 1<= n < 50000  
> 2. 初始默认的进制是十进制
> 
> 资源约定：  
> 峰值内存消耗 < 256M  
> CPU消耗  < 1000ms
> 
>   
> 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
> 
> 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
> 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
> 注意：主类的名字必须是：Main，否则按无效代码处理。

# 五、填字母游戏（程序设计 满分71分） #

> 标题：填字母游戏
> 
> 小明经常玩 LOL 游戏上瘾，一次他想挑战K大师，不料K大师说：  
> “我们先来玩个空格填字母的游戏，要是你不能赢我，就再别玩LOL了”。
> 
> K大师在纸上画了一行n个格子，要小明和他交替往其中填入字母。
> 
> 并且：
> 
> 1. 轮到某人填的时候，只能在某个空格中填入L或O  
> 2. 谁先让字母组成了“LOL”的字样，谁获胜。  
> 3. 如果所有格子都填满了，仍无法组成LOL，则平局。
> 
> 小明试验了几次都输了，他很惭愧，希望你能用计算机帮他解开这个谜。
> 
> 本题的输入格式为：  
> 第一行，数字n（n<10），表示下面有n个初始局面。  
> 接下来，n行，每行一个串，表示开始的局面。  
>   比如：“\*\*\*\*\*\*”, 表示有6个空格。  
>   “L\*\*\*\*”,   表示左边是一个字母L，它的右边是4个空格。
> 
> 要求输出n个数字，表示对每个局面，如果小明先填，当K大师总是用最强着法的时候，小明的最好结果。  
> 1 表示能赢  
> \-1 表示必输  
> 0 表示可以逼平
> 
>   
> 例如，  
> 输入：  
> 4  
> \*\*\*  
> L\*\*L  
> L\*\*L\*\*\*L  
> L\*\*\*\*\*L
> 
> 则程序应该输出：  
> 0  
> \-1  
> 1  
> 1
> 
> 资源约定：  
> 峰值内存消耗 < 256M  
> CPU消耗  < 1000ms
> 
>   
> 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
> 
> 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
> 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
> 注意：主类的名字必须是：Main，否则按无效代码处理。

# 六、区间移位（程序设计 满分101分） #

> 标题：区间移位
> 
> 数轴上有n个闭区间：D1,...,Dn。  
> 其中区间Di用一对整数\[ai, bi\]来描述，满足ai < bi。  
> 已知这些区间的长度之和至少有10000。  
> 所以，通过适当的移动这些区间，你总可以使得他们的“并”覆盖\[0, 10000\]——也就是说\[0, 10000\]这个区间内的每一个点都落于至少一个区间内。  
> 你希望找一个移动方法，使得位移差最大的那个区间的位移量最小。
> 
> 具体来说，假设你将Di移动到\[ai+ci, bi+ci\]这个位置。你希望使得maxi\{|ci|\} 最小。
> 
> 【输入格式】  
> 输入的第一行包含一个整数n，表示区间的数量。  
> 接下来有n行，每行2个整数ai, bi，以一个空格分开，表示区间\[ai, bi\]。  
> 保证区间的长度之和至少是10000。
> 
> 【输出格式】  
> 输出一个数字，表示答案。如果答案是整数，只输出整数部分。如果答案不是整数，输出时四舍五入保留一位小数。
> 
> 【样例输入】  
> 2  
> 10 5010  
> 4980 9980
> 
> 【样例输出】  
> 20
> 
> 【样例说明】  
> 第一个区间往左移动10；第二个区间往右移动20。
> 
> 【样例输入】  
> 4  
> 0 4000  
> 3000 5000  
> 5001 8000  
> 7000 10000  
> 【样例输出】  
> 0.5  
> 【样例说明】  
> 第2个区间往右移0.5；第3个区间往左移0.5即可。
> 
> 【数据规模与约定】  
> 对于30%的评测用例，1 <= n <= 10；  
> 对于100%的评测用例，1 <= n <= 10000，0 <= ai < bi <= 10000。
> 
> 资源约定：  
> 峰值内存消耗 < 256M  
> CPU消耗  < 2000ms
> 
>   
> 请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
> 
> 所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。  
> 注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。  
> 注意：主类的名字必须是：Main，否则按无效代码处理。
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 1][]
> 
> ![20201108220723752.png][]

# 小结 #

> 好难的题！！！

[Java B_ _ _2013_4_2020_11]: https://blog.csdn.net/weixin_44949135/article/details/108230143
[11_ _-_1_2_-_2020_3_4_-]: https://blog.csdn.net/weixin_44949135/article/details/106223446
[_Java B]: http://dasai.lanqiao.cn/pages/dasai/news_detail_w.html?id=644
[Link 1]: https://blog.csdn.net/zhengwei223
[2013_ _04_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108087292
[2014_ _05_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108098676
[2015_ _06_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108123806
[2016_ _07_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108142487
[2017_ _08_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108143554
[2018_ _09_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108144284
[2019_10_ _ Java B_]: https://blog.csdn.net/weixin_44949135/article/details/108150820
[2020_11_ _ _1_Java]: https://blog.csdn.net/weixin_44949135/article/details/108179383
[2020_11_ _ _2_Java]: https://blog.csdn.net/weixin_44949135/article/details/108203734
[2020_11_ _ C_C_ B_ _1_ 2020.07.05]: https://blog.csdn.net/weixin_44949135/article/details/108232922
[2020_11_ _ Java B_ _1_ 2020.07.05]: https://blog.csdn.net/weixin_44949135/article/details/108228625
[2020_ _11_ _ Java B_ _2_ 2020.10.17]: https://blog.csdn.net/weixin_44949135/article/details/109402088
[2020_11_ _ Java C_ _1_ 2020.07.05]: https://blog.csdn.net/weixin_44949135/article/details/108240826
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70]: /images/20221120/961c1c1f36f7445790c356ba6dbf7f9c.png
[20201110193819782.png]: https://img-blog.csdnimg.cn/20201110193819782.png
[20201110193712411.png]: https://img-blog.csdnimg.cn/20201110193712411.png
[20201110194109800.png]: https://img-blog.csdnimg.cn/20201110194109800.png
[20201110193420160.png]: https://img-blog.csdnimg.cn/20201110193420160.png
[wyk]: https://blog.csdn.net/qq_43652327/article/details/109439697
[20201110194152627.png]: https://img-blog.csdnimg.cn/20201110194152627.png
[20201110193247320.png]: https://img-blog.csdnimg.cn/20201110193247320.png
[20201108220510614.png]: https://img-blog.csdnimg.cn/20201108220510614.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201108220701532.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk0OTEzNQ==,size_16,color_FFFFFF,t_70
[20201108220723752.png]: https://img-blog.csdnimg.cn/20201108220723752.png