modify all lanqiao solution format problem

data_backup/3.蓝桥杯/101.荒岛探测/solution.md

@@ -12,29 +12,41 @@
 
 请计算，小蓝在荒岛上可以探测到的面积有多大？
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含五个整数，分别为 $x_A$,$y_A$,$x_B$,$y_B$,L  
 第二行包含六个整数，分别为 $x_1$,$y_1$,$x_2$,$y_2$,$x_3$,$y_3$ 。
 
-#### 输出格式
+
+**输出格式**
+
 输出一行，包含一个实数，四舍五入保留2位小数，表示答案。  
 考虑到计算中的误差，只要你的输出与参考输出相差不超过0.01即可。
-#### 样例输入
+
+**样例输入**
+
 ```
 10 6 4 12 12
 0 2 13 2 13 15
 ```
-#### 输出样例
+
+**输出样例**
+
 ```
 39.99
 ```
-#### 样例说明
+
+**样例说明**
+
 荒岛的形状和定位设备工作正常的区域如下图所示，蓝色的三角形表示荒岛，红色的曲线围成的区域为定位设备工作正常的区域。   
 ![](https://img-blog.csdnimg.cn/20210402235557403.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NKTF9hc0xvbmc3Mg==,size_16,color_FFFFFF,t_70#pic_center)
 
 当输出为 39.98、39.99 或 40.00 时可以得分。
 
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 对于所有评测用例，保证发射器的两个坐标不同，$ -1000 \leq x_A,y_A,x_B,y_B\leq 1000$,$ -1000 \leq x_1,y_1,x_2,y_2,x_3,y_3\leq 1000$, $ -1000 \leq L \leq 1000 $。
 
 

data_backup/3.蓝桥杯/103.买不到的数目/solution.md

 # 买不到的数目
 
-#### 问题描述
+
+**问题描述**
+
 
 小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。
 
@@ -10,27 +12,39 @@
 
 本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。
 
-#### 输入格式
+
+**输入格式**
+
 
 两个正整数，表示每种包装中糖的颗数(都不多于1000)
 
-#### 输出格式
+
+**输出格式**
+
 
 一个正整数，表示最大不能买到的糖数
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 4 7
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 17
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 3 5
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 7
 ```

data_backup/3.蓝桥杯/106.错误票据/solution.md

 # 错误票据
-#### 问题描述
+
+**问题描述**
+
 某涉密单位下发了某种票据，并要在年终全部收回。
 
 每张票据有唯一的ID号。全年所有票据的ID号是连续的，但ID的开始数码是随机选定的。
@@ -10,7 +12,9 @@
 
 假设断号不可能发生在最大和最小号。
 
-#### 输入格式
+
+**输入格式**
+
 要求程序首先输入一个整数N(N<100)表示后面数据行数。
 
 接着读入N行数据。
@@ -19,22 +23,30 @@
 
 每个整数代表一个ID号。
 
-#### 输出格式
+
+**输出格式**
+
 要求程序输出1行，含两个整数m n，用空格分隔。
 
 其中，m表示断号ID，n表示重号ID
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 2
 5 6 8 11 9
 10 12 9
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 7 9
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 6
 164 178 108 109 180 155 141 159 104 182 179 118 137 184 115 124 125 129 168 196
@@ -44,7 +56,9 @@
 149 138 142 146 199 126 165 156 153 193 144 166 170 121 171 132 101 194 187 188
 113 130 176 154 177 120 117 150 114 183 186 181 100 163 160 167 147 198 111 119
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 105 120
 ```

data_backup/3.蓝桥杯/108.高斯日记/solution.md

@@ -17,7 +17,9 @@
 
 
 请你算出高斯获得博士学位的年月日。
-#### 输出格式
+
+**输出格式**
+
 提交答案的格式是：yyyy-mm-dd, 例如：1980-03-21
 
 ## aop

data_backup/3.蓝桥杯/109.后缀表达式/solution.md

 # 后缀表达式
 
-#### 问题描述
+
+**问题描述**
+
 
 给定 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，−10^9 ≤ Ai ≤10^9。
 

data_backup/3.蓝桥杯/116.子串分值/solution.md

 # 子串分值
 
-#### 题目描述
+
+**题目描述**
+
 对于一个字符串 S，我们定义 S 的分值 f(S)为 S 中出现的不同的字符个数。
 
 例如f(“aba”)=2，f(“abc”)=3，f(“aaa”)=1。
 
 现在给定一个字符串 S[0…n−1]（长度为 n），请你计算对于所有S的非空子串S[i…j] (0≤i≤j<n)，f(S[i…j]) 的和是多少。
 
-#### 输入格式
+
+**输入格式**
+
 输入一行包含一个由小写字母组成的字符串 S。
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数表示答案。
 
-#### 输入样例
+
+**输入样例**
+
 ```
 ababc
 ```
-#### 输出样例
+
+**输出样例**
+
 ```
 21
 ```

data_backup/3.蓝桥杯/117.地宫取宝/solution.md

@@ -6,37 +6,51 @@ X 国王有一个地宫宝库，是 n×m 个格子的矩阵，每个格子放一
 当小明走到出口时，如果他手中的宝贝恰好是 k 件，则这些宝贝就可以送给小明。
 请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这 k 件宝贝。
 
-#### 输入格式
+
+**输入格式**
+
 第一行 3 个整数，n,m,k，含义见题目描述。
 接下来 n 行，每行有 m 个整数 Ci 用来描述宝库矩阵每个格子的宝贝价值。
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，表示正好取 k 个宝贝的行动方案数。
 该数字可能很大，输出它对 1000000007 取模的结果。
 
-#### 数据范围
+
+**数据范围**
+
 ```
 1≤n,m≤50,
 1≤k≤12,
 0≤Ci≤12
 ```
-#### 输入样例1：
+
+**输入样例1：**
+
 ```
 2 2 2
 1 2
 2 1
 ```
-#### 输出样例1：
+
+**输出样例1：**
+
 ```
 2
 ```
-#### 输入样例2：
+
+**输入样例2：**
+
 ```
 2 3 2
 1 2 3
 2 1 5
 ```
-#### 输出样例2：
+
+**输出样例2：**
+
 ```
 14
 ```

data_backup/3.蓝桥杯/118.全球变暖/solution.md

@@ -28,21 +28,29 @@
 ```
 请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
 
-#### 输入格式
+
+**输入格式**
+
 第一行包含一个整数N。
 
 以下 N 行 N 列，包含一个由字符”#”和”.”构成的 N×N 字符矩阵，代表一张海域照片，”#”表示陆地，”.”表示海洋。
 
 照片保证第 1 行、第 1 列、第 N 行、第 N 列的像素都是海洋。
 
-#### 输出格式
+
+**输出格式**
+
 一个整数表示答案。
 
-#### 数据范围
+
+**数据范围**
+
 ```
 1≤N≤1000
 ```
-#### 输入样例1：
+
+**输入样例1：**
+
 ```
 7
 .......
@@ -53,11 +61,15 @@
 ...###.
 .......
 ```
-#### 输出样例1：
+
+**输出样例1：**
+
 ```
 1
 ```
-#### 输入样例2：
+
+**输入样例2：**
+
 ```
 9
 .........
@@ -70,7 +82,9 @@
 .#..#....
 .........
 ```
-#### 输出样例2：
+
+**输出样例2：**
+
 ```
 1
 ```

data_backup/3.蓝桥杯/119.走方格/solution.md

 # 走方格
 
-#### 问题描述
+
+**问题描述**
+
 在平面上有一些二维的点阵。这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下走。注意，如果行号和列数都是偶数，不能走入这一格中。问有多少种方案。
 
-#### 输入格式
+
+**输入格式**
+
 输入一行包含两个整数 n, m。
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，表示答案。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 3 4
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 2
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 6 6
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 0
 ```
-#### 测试数据
+
+**测试数据**
+
 对于所有评测用例，1 ≤ n ≤ 30, 1 ≤ m ≤ 30。
 
 

data_backup/3.蓝桥杯/120.成绩统计/solution.md

 # 成绩统计
-#### 问题描述
+
+**问题描述**
+
 编写一个程序，建立了一条单向链表，每个结点包含姓名、学号、英语成绩、数学成绩和C++成绩，并通过链表操作平均最高的学生和平均分最低的学生并且输出。  
-#### 输入格式
+
+**输入格式**
+
 输入n+1行，第一行输入一个正整数n，表示学生数量；接下来的n行每行输入5个数据，分别表示姓名、学号、英语成绩、数学成绩和C++成绩。注意成绩有可能会有小数。  
-#### 输出格式
+
+**输出格式**
+
 输出两行，第一行输出平均成绩最高的学生姓名。第二行输出平均成绩最低的学生姓名。  
-#### 样例输入
+
+**样例输入**
+
 ```
 2
 yx1 1 45 67 87
 yx2 2 88 90 99
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 yx2
 yx1

data_backup/3.蓝桥杯/124.堆的计数/solution.md

 # 堆的计数
-#### 题目描述
+
+**题目描述**
+
 我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。  
 每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。  
  
@@ -29,25 +31,35 @@
 由于数量可能超过整型范围，你只需要输出结果除以1000000009的余数。  
  
  
-#### 输入格式
+
+**输入格式**
+
 一个整数N。  
 对于40%的数据，1 <= N <= 1000  
 对于70%的数据，1 <= N <= 10000  
 对于100%的数据，1 <= N <= 100000
  
-#### 输出格式
+
+**输出格式**
+
 一个整数表示答案。  
  
-#### 输入样例
+
+**输入样例**
+
 ```
 4
 ```  
  
-#### 输出样例
+
+**输出样例**
+
 ```
 3
 ``` 
-#### 资源约定：  
+
+**资源约定：  **
+
 峰值内存消耗（含虚拟机） < 256M  
 CPU消耗  < 1000ms
 

data_backup/3.蓝桥杯/127.解密/solution.md

 # 解密
 
-#### 问题描述
+
+**问题描述**
+
 RSA 是一种经典的加密算法。它的基本加密过程如下。  
 首先生成两个质数 p, q，令 n = p · q，设 d 与 (p − 1) · (q − 1) 互质，则可找到 e 使得 d · e 除 (p − 1) · (q − 1) 的余数为 1。
 n, d, e 组成了私钥，n, d 组成了公钥。  

data_backup/3.蓝桥杯/13.迷宫/solution.md

@@ -44,7 +44,6 @@
 10000010100101001010110000000100101010001011101000
 00111100001000010000000110111000000001000000001011
 10000001100111010111010001000110111010101101111000
-
 ```
 
 ## aop

data_backup/3.蓝桥杯/131.最大比例/solution.md

@@ -14,44 +14,62 @@ X星球的某个大奖赛设了 M 级奖励。
 
 请你据此推算可能的最大的等比值。
 
-#### 输入格式
+
+**输入格式**
+
 第一行为数字 N ，表示接下的一行包含 N 个正整数。
 
 第二行 N 个正整数 Xi，用空格分开，每个整数表示调查到的某人的奖金数额。
 
-#### 输出格式
+
+**输出格式**
+
 一个形如 A/B 的分数，要求 A、B 互质，表示可能的最大比例系数。
 
-#### 数据范围
+
+**数据范围**
+
 
 $0< N < 100$  
 $0 < X_i < 10^12$  
 数据保证一定有解。
 
-#### 输入样例1：
+
+**输入样例1：**
+
 ```
 3
 1250 200 32
 ```
-#### 输出样例1：
+
+**输出样例1：**
+
 ```
 25/4
 ```
-#### 输入样例2：
+
+**输入样例2：**
+
 ```
 4
 3125 32 32 200
 ```
-#### 输出样例2：
+
+**输出样例2：**
+
 ```
 5/2
 ```
-#### 输入样例3：
+
+**输入样例3：**
+
 ```
 3
 549755813888 524288 2
 ```
-#### 输出样例3：
+
+**输出样例3：**
+
 ```
 4/1
 ```

data_backup/3.蓝桥杯/132.数字三角形/solution.md

 # 数字三角形
 
-#### 题目描述
+
+**题目描述**
+
 
 ![](https://img-blog.csdnimg.cn/20210330204547371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjIzOTM3MA==,size_16,color_FFFFFF,t_70)
 
@@ -14,15 +16,21 @@
 
 此外，向左下走的次数与向右下走的次数相差不能超过 1。
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含一个整数 N，表示三角形的行数。  
 下面的 N 行给出数字三角形。  
 数字三角形上的数都是 0 至 100 之间的整数。  
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，表示答案。
 
-#### 输入样例
+
+**输入样例**
+
 ```
 5
 7
@@ -31,7 +39,9 @@
 2 7 4 4
 4 5 2 6 5
 ```
-#### #### 输出样例
+
+**输出样例**
+
 ```
 27
 ```

data_backup/3.蓝桥杯/134.第几天/solution.md

@@ -2,19 +2,27 @@
 y年m月d日是哪一年的第几天。  
 比如y年的1月1日是那一年的第一天，那么y年m月d日是哪一年的第几天。  
 
-#### 输入
+
+**输入**
+
 ```
 y m d
 ```
-#### 输出
+
+**输出**
+
 输出一个整数
 
 ### 样例
-#### 输入
+
+**输入**
+
 ```
 2000 7 7
 ```
-#### 输出
+
+**输出**
+
 ```
 189
 ```

data_backup/3.蓝桥杯/135.斐波那契/solution.md

 # 斐波那契
 Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
 当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
-#### 输入格式
+
+**输入格式**
+
 输入包含一个整数n。  
 输出格式  
 输出一行，包含一个整数，表示Fn除以10007的余数。  
 说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
-#### 样例输入
+
+**样例输入**
+
 ```
 10
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 55
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 22
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 7704
 ```
-#### 数据规模与约定
+
+**数据规模与约定**
+
 ```
 1 <= n <= 1,000,000。
 ```

data_backup/3.蓝桥杯/136.日期问题/solution.md

@@ -6,19 +6,27 @@
  
 给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
  
-#### 输入
+
+**输入**
+
 
 一个日期，格式是"AA/BB/CC"。  (0 <= A, B, C <= 9)  
  
-#### 输出
+
+**输出**
+
 
 输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。  
  
-#### 样例输入
+
+**样例输入**
+
 ```
 02/03/04  
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 2002-03-04  
 2004-02-03  

data_backup/3.蓝桥杯/140.完全二叉树的权值/solution.md

 # 完全二叉树的权值
 
-#### 问题描述
+
+**问题描述**
+
 给定一棵包含 N 个节点的完全二叉树，树上每个节点都有一个权值，按从上到下、从左到右的顺序依次是 A 1 , A 2 , ··· A N ，如下图所示：  
 ![](https://img-blog.csdnimg.cn/20210402205939738.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc5NjMxNg==,size_16,color_FFFFFF,t_70)
 
@@ -8,21 +10,31 @@
 权值之和最大？如果有多个深度的权值和同为最大，请你输出其中最小的深度。  
 
 **注：根的深度是 1。**
-#### 输入格式
+
+**输入格式**
+
 第一行包含一个整数 N。
 第二行包含 N 个整数 A 1 , A 2 , ··· A N 。
-#### 输出格式
+
+**输出格式**
+
 输出一个整数代表答案。
-#### 样例输入
+
+**样例输入**
+
 ```
 7
 1 6 5 4 3 2 1
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 2
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 对于所有评测用例，1 ≤ N ≤ 100000，−100000 ≤ A i ≤ 100000。
 
 

data_backup/3.蓝桥杯/143.带分数/solution.md

 # 带分数
-#### 问题描述
+
+**问题描述**
+
 100 可以表示为带分数的形式：100 = 3 + 69258 / 714。
 
 还可以表示为：100 = 82 + 3546 / 197。
@@ -8,27 +10,39 @@
 
 类似这样的带分数，100 有 11 种表示法。
 
-#### 输入格式
+
+**输入格式**
+
 从标准输入读入一个正整数N (N<1000*1000)
 
-#### 输出格式
+
+**输出格式**
+
 程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
 
 注意：不要求输出每个表示，只统计有多少表示法！
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 100
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 11
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 105
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 6
 ```

data_backup/3.蓝桥杯/144.矩阵翻硬币/solution.md

 # 矩阵翻硬币
 
-#### 问题描述
+
+**问题描述**
+
 小明先把硬币摆成了一个 n 行 m 列的矩阵。  
 随后，小明对每一个硬币分别进行一次 Q 操作。  
 对第x行第y列的硬币进行 Q 操作的定义：将所有第 $i*x$ 行，第 $j*y$ 列的硬币进行翻转。  
@@ -8,19 +10,29 @@
 当小明对所有硬币都进行了一次 Q 操作后，他发现了一个奇迹——所有硬币均为正面朝上。  
 小明想知道最开始有多少枚硬币是反面朝上的。于是，他向他的好朋友小M寻求帮助。  
 聪明的小M告诉小明，只需要对所有硬币再进行一次Q操作，即可恢复到最开始的状态。然而小明很懒，不愿意做。于是小明希望你给出他更好的方法。帮他计算出答案。  
-#### 输入格式
+
+**输入格式**
+
 输入数据包含一行，两个正整数 n m，含义见题目描述。
-#### 输出格式
+
+**输出格式**
+
 输出一个正整数，表示最开始有多少枚硬币是反面朝上的。
-#### 样例输入
+
+**样例输入**
+
 ```
 2 3
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 1
 ```
-#### 数据规模和约定
+
+**数据规模和约定**
+
 对于10%的数据，n、m <= 10^3；  
 对于20%的数据，n、m <= 10^7；  
 对于40%的数据，n、m <= 10^15；  

data_backup/3.蓝桥杯/146.生命之树/solution.md

@@ -16,7 +16,9 @@
 
 他需要你为他写一个程序来计算一棵树的分数。
 
-#### 输入格式
+
+**输入格式**
+
 第一行一个整数 n 表示这棵树有 n 个节点。
 
 第二行 n 个整数，依次表示每个节点的评分。
@@ -27,15 +29,21 @@
 
 树的节点编号从 1 到 n。
 
-#### 输出格式
+
+**输出格式**
+
 输出一行一个数，表示上帝给这棵树的分数。
 
-#### 数据范围
+
+**数据范围**
+
 ```
 1≤n≤105,
 每个节点的评分的绝对值均不超过 10的6次方。
 ```
-#### 输入样例：
+
+**输入样例：**
+
 ```
 5
 1 -2 -3 4 5
@@ -44,7 +52,9 @@
 1 2
 2 5
 ```
-#### 输出样例：
+
+**输出样例：**
+
 ```
 8
 ```

data_backup/3.蓝桥杯/147.蚂蚁感冒/solution.md

 # 蚂蚁感冒
 
-#### 题目描述
+
+**题目描述**
+
 长 100 厘米的细长直杆子上有 n 只蚂蚁。
 
 它们的头有的朝左，有的朝右。
@@ -15,7 +17,9 @@
 
 请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。
 
-#### 输入格式
+
+**输入格式**
+
 第一行输入一个整数 n, 表示蚂蚁的总数。
 
 接着的一行是 n 个用空格分开的整数 Xi, Xi 的绝对值表示蚂蚁离开杆子左边端点的距离。
@@ -24,29 +28,41 @@
 
 其中，第一个数据代表的蚂蚁感冒了。
 
-#### 输出格式
+
+**输出格式**
+
 输出1个整数，表示最后感冒蚂蚁的数目。
 
-#### 数据范围
+
+**数据范围**
+
 ```
 1<n<50,
 0<|Xi|<100
 ```
-#### 输入样例1：
+
+**输入样例1：**
+
 ```
 3
 5 -2 8
 ```
-#### 输出样例1：
+
+**输出样例1：**
+
 ```
 1
 ```
-#### 输入样例2：
+
+**输入样例2：**
+
 ```
 5
 -10 8 -20 12 25
 ```
-#### 输出样例2：
+
+**输出样例2：**
+
 ```
 3
 ```

data_backup/3.蓝桥杯/149.方阵转置/solution.md

 # 方阵转置
-#### 问题描述
+
+**问题描述**
+
 
 给定一个n×m矩阵相乘，求它的转置。其中1≤n≤20，1≤m≤20，矩阵中的每个元素都在整数类型（4字节）的表示范围内。
-#### 输入格式
+
+**输入格式**
+
 第一行两个整数n和m；  
 第二行起，每行m个整数，共n行，表示n×m的矩阵。数据之间都用一个空格分隔。
-#### 输出格式
+
+**输出格式**
+
 
 共m行，每行n个整数，数据间用一个空格分隔，表示转置后的矩阵。
-#### 样例输入
+
+**样例输入**
+
 ```
 2 4
 34 76 -54 7
 -4 5 23 9
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 34 -4
 76 5

data_backup/3.蓝桥杯/150.剪格子/solution.md

 # 剪格子
 
-#### 问题描述
+
+**问题描述**
+
 如下图所示，3 x 3 的格子中填写了一些整数。  
 ```
 +--*--+--+
@@ -19,34 +21,46 @@
 
 如果无法分割，则输出 0。
 
-#### 输入格式
+
+**输入格式**
+
 程序先读入两个整数 m n 用空格分割 (m,n<10)。
 
 表示表格的宽度和高度。
 
 接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000。
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，表示在所有解中，包含左上角的分割区可能包含的最小的格子数目。
-#### 样例输入1
+
+**样例输入1**
+
 ```
 3 3
 10 1 52
 20 30 1
 1 2 3
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 3
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 4 3
 1 1 1 1
 1 30 80 2
 1 1 1 100
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 10
 ```

data_backup/3.蓝桥杯/151.连号区间数/solution.md

 # 连号区间数
 
-#### 问题描述
+
+**问题描述**
+
 小明这些天一直在思考这样一个奇怪而有趣的问题：  
 在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是：  
 如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。  
 当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助。
 
-#### 输入格式
+
+**输入格式**
+
 第一行是一个正整数N (1 <= N <= 50000), 表示全排列的规模。  
 第二行是N个不同的数字Pi(1 <= Pi <= N)， 表示这N个数字的某一全排列。  
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，表示不同连号区间的数目。
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 4
 3 2 4 1
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 7
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 5
 3 4 2 5 1
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 9
 ```

data_backup/3.蓝桥杯/153.整数拼接/solution.md

 # 整数拼接
 
-#### 问题描述
+
+**问题描述**
+
 给定义个长度为 n 的数组 $A_1, A_2 , ··· , A_n$。
 
 你可以从中选出两个数 $A_i 和 A_j$ (i 不等于 j)，然后将 $A_i 和 A_j$ 一前一后拼成一个新的整数。
@@ -11,24 +13,34 @@
 
 请你计算有多少种拼法满足拼出的整数是 K 的倍数。
 
-#### 输入格式
+
+**输入格式**
+
 第一行包含 2 个整数 n 和 K。
 第二行包含 n 个整数 $A_1, A_2 , ··· , A_n$。
 
 
-#### 输出格式
+
+**输出格式**
+
 一个整数代表答案。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 4 2
 1 2 3 4
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 6
 ```
-#### 数据范围
+
+**数据范围**
+
 对于 30% 的评测用例，1 ≤ n ≤ 1000, 1 ≤ K ≤ 20, 1 ≤ $A_i$ ≤ $10^4$  
 对于所有评测用例，1 ≤ n ≤ $10^5$，1 ≤ K ≤ $10^5$ ，1 ≤ $A_i$ ≤ $10^9$
 

data_backup/3.蓝桥杯/154.小朋友崇拜圈/solution.md

 # 小朋友崇拜圈
 
-#### 问题描述：
+
+**问题描述：**
+
 
 班里 N个小朋友，每个人都有自己最崇拜的一个小朋友（也可以是自己）。在一个游戏中，需要小朋友坐一个圈，每个小朋友都有自己最崇拜的小朋友在他的右手边。求满足条件的圈最大多少人？小朋友编号为1，2，3....N
 
-#### 输入描述
+
+**输入描述**
+
 
 输入第一行，一个整数N(3 < N < 100000)
 
 接下来一行 N个整数，由空格分开。
 
-#### 输出描述
+
+**输出描述**
+
 
 要求输出一个整数，表示满足条件的最大圈的人数。
 
-### 输入输出样例
-#### 输入
+
+输入输出样例：
+
+**输入**
+
 ```
 9
 3 4 2 5 3 8 4 6 9
 ```
-#### 输出
+
+**输出**
+
 ```
 4
 ```
-#### 样例解释
+
+**样例解释**
+
 
 如下图所示，崇拜关系用箭头表示，红色表示不在圈中。  
 显然，最大圈是[2 4 5 3] 构成的圈。
 
 ![](https://img-blog.csdnimg.cn/20190317193536482.png)
 
-#### 输入：
+
+**输入：**
+
 ```
 30
 22 28 16 6 27 21 30 1 29 10 9 14 24 11 7 2 8 5 26 4 12 3 25 18 20 19 23 17 13 15
 ```
-#### 输出：
+
+**输出：**
+
 ```
 16
 ```

data_backup/3.蓝桥杯/157.外卖店优先级/solution.md

 # 外卖店优先级
 
-#### 问题描述
+
+**问题描述**
+
 “饱了么”外卖系统中维护着 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
@@ -20,13 +28,19 @@
 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。

data_backup/3.蓝桥杯/158.倍数问题/solution.md

 # 倍数问题
-####  题目描述
+
+**题目描述**
+
 众所周知，小葱同学擅长计算，尤其擅长计算一个数是否是另外一个数的倍数。但小葱只擅长两个数的情况，当有很多个数之后就会比较苦恼。现在小葱给了你 n 个数，希望你从这 n 个数中找到三个数，使得这三个数的和是 K 的倍数，且这个和最大。数据保证一定有解。
 
-#### 输入格式
+
+**输入格式**
+
 从标准输入读入数据。
 第一行包括 2 个正整数 n, K。
 第二行 n 个正整数，代表给定的 n 个数。
 
-#### 输出格式
+
+**输出格式**
+
 输出到标准输出。
 输出一行一个整数代表所求的和。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 4 3
 1 2 3 4
 ```
 
-#### 样例输出
+
+**样例输出**
+
 ```
 9
 ```
 
-#### 样例解释
+
+**样例解释**
+
 ```
 选择2、3、4。
 ```

data_backup/3.蓝桥杯/159.排序/solution.md

 # 排序
 
-#### 问题描述
+
+**问题描述**
+
 编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。  
 输入格式：输入只有一行，即三个整数，中间用空格隔开。  
 输出格式：输出只有一行，即排序后的结果。  
-### 输入输出样例
-#### 样例输入
+
+输入输出样例：
+
+**样例输入**
+
 ```
 9 2 30
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 30 9 2
 ```

data_backup/3.蓝桥杯/162.7段码/solution.md

 # 7段码
-#### 题目描述
+
+**题目描述**
+
 小蓝要用七段码数码管来表示一种特殊的文字。  
 ![七段码](https://img-blog.csdnimg.cn/2020110916441977.png#pic_left)   
 上图给出了七段码数码管的一个图示，数码管中一共有 7 段可以发光的二极管，分别标记为 a, b, c, d, e, f, g。

data_backup/3.蓝桥杯/163.等差数列/solution.md

 # 等差数列
-#### 题目描述
+
+**题目描述**
+
 数学老师给小明出了一道等差数列求和的题目。
 
 但是粗心的小明忘记了一部分的数列，只记得其中 N 个整数。
 
 现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有几项？
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含一个整数 N。
 
 第二行包含 N 个整数 A1,A2,⋅⋅⋅,AN。(注意 A1∼AN 并不一定是按等差数
 列中的顺序给出)
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数表示答案。
 
-#### 输入样例：
+
+**输入样例：**
+
 ```
 5
 2 6 4 10 20
 ```
-#### 输出样例：
+
+**输出样例：**
+
 ```
 10
 ```
-#### 样例解释
+
+**样例解释**
+
 包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、18、20。
 
 

data_backup/3.蓝桥杯/167.快速排序/solution.md

 # 快速排序
 
-#### 问题描述
+
+**问题描述**
+
 用递归来实现快速排序（quick sort）算法。快速排序算法的基本思路是：假设要对一个数组a进行排序，且a[0] = x。首先对数组中的元素进行调整，使x放在正确的位置上。同时，所有比x小的数都位于它的左边，所有比x大的数都位于它的右边。然后对于左、右两段区域，递归地调用快速排序算法来进行排序。
-#### 输入格式：
+
+**输入格式：**
+
 输入只有一行，包括若干个整数（不超过10个），以0结尾。
-#### 输出格式：
+
+**输出格式：**
+
 输出只有一行，即排序以后的结果（不包括末尾的0）。
-### 输入输出样例
-#### 样例输入
+
+输入输出样例：
+
+**样例输入**
+
 ```
 5 2 6 1 7 3 4 0
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 1 2 3 4 5 6 7
 ```

data_backup/3.蓝桥杯/168.移动距离/solution.md

@@ -15,7 +15,9 @@ w为排号宽度，m,n为待计算的楼号。
 要求输出一个整数，表示m n 两楼间最短移动距离。  
 
 例如：
-#### 用户输入：
+
+**用户输入：**
+
 ```
 6 8 2
 ```
@@ -24,7 +26,9 @@ w为排号宽度，m,n为待计算的楼号。
 4
 ```
 再例如：
-#### 用户输入：
+
+**用户输入：**
+
 ```
 4 7 20
 ```

data_backup/3.蓝桥杯/170.幸运数/solution.md

 # 幸运数
 
-#### 问题描述
+
+**问题描述**
+
 幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。  
 首先从1开始写出自然数1,2,3,4,5,6,…  
 1 就是第一个幸运数。  
@@ -14,24 +16,36 @@
 ```
 1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, …
 ```
-#### 输入格式
+
+**输入格式**
+
 输入两个正整数m n, 用空格分开 (m < n < 1000*1000)
 
-#### 输出格式
+
+**输出格式**
+
 程序输出 位于m和n之间的幸运数的个数（不包含m和n）。
-#### 样例输入1
+
+**样例输入1**
+
 ```
 1 20
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 5
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 30 69
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 8
 ```

data_backup/3.蓝桥杯/171.加法变乘法/solution.md

 # 加法变乘法
 
-#### 题目描述：
+
+**题目描述：**
+
 我们都知道：1+2+3+ … + 49 = 1225
 
 现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

data_backup/3.蓝桥杯/172.修改数组/solution.md

 # 修改数组
 
-#### 问题描述
+
+**问题描述**
+
 给定一个长度为 N 的数组$ A = [A_1; A_2; · · · A_N]$，数组中有可能有重复出现的整数。  
 现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改$A_2, A_3, · · · , A_N$。  
 当修改 $A_i$时，小明会检查 $A_i$ 是否在$ A_1 ∼ A_{i−1} $中出现过。如果出现过，则小明会给$ A_i $加上 1 ；如果新的$ A_i $仍在之前出现过，小明会持续给$ A_i $加 1 ，直到$ A_i $没有在$ A_1 ∼ A_{i−1}$ 中出现过。
 当$ A_N $也经过上述修改之后，显然 A 数组中就没有重复的整数了。  
 现在给定初始的 A 数组，请你计算出最终的 A 数组。  
 
-#### 输入格式
+
+**输入格式**
+
 第一行包含一个整数 N。  
 第二行包含 N 个整数$ A_1; A_2; · · · ; A_N $。
 
-#### 输出格式
+
+**输出格式**
+
 输出 N 个整数，依次是最终的$ A_1; A_2; · · · ; A_N $。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 5
 2 1 1 3 4
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 2 1 3 4 5
 ```

data_backup/3.蓝桥杯/176.油漆面积/solution.md

 # 油漆面积
 
-#### 问题描述
+
+**问题描述**
+
 X星球的一批考古机器人正在一片废墟上考古。  
 该区域的地面坚硬如石、平整如镜。  
 管理人员为方便，建立了标准的直角坐标系。  
@@ -13,31 +15,43 @@ X星球的一批考古机器人正在一片废墟上考古。
 注意，各个矩形间可能重叠。  
 本题的输入为若干矩形，要求输出其覆盖的总面积。  
 　　
-#### 输入格式
+
+**输入格式**
+
 第一行，一个整数n，表示有多少个矩形(1<=n<10000)  
 接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。  
 (0<= x1,y1,x2,y2 <=10000)  
-#### 输出格式
+
+**输出格式**
+
 一行一个整数，表示矩形覆盖的总面积面积。
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 1 5 10 10
 3 1 20 20
 2 7 15 17
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 340
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 5 2 10 6
 2 7 12 10
 8 1 15 15
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 128
 ```

data_backup/3.蓝桥杯/177.密码发生器/solution.md

@@ -19,12 +19,18 @@ ming
 
 要求程序从标准输入接收数据，在标准输出上输出结果。
 
-#### 输入格式为：
+
+**输入格式为：**
+
 第一行是一个整数n（<100），表示下边有多少输入行，接下来是n行字符串，就是等待变换的符串。
-#### 输出格式为：
+
+**输出格式为：**
+
 n行变换后的6位密码。
 
-#### 输入：
+
+**输入：**
+
 ```
 5
 zhangfeng
@@ -33,7 +39,9 @@ jiujingfazi
 woaibeijingtiananmen
 haohaoxuexi
 ```
-#### 输出：
+
+**输出：**
+
 ```
 772243
 344836

data_backup/3.蓝桥杯/179.整除序列/solution.md

 # 整除序列
 
 有一个序列，序列的第一个数是n，后面的每个数是前一个数整除2，请输出这个序列中值为正数的项。
-#### 输入格式
+
+**输入格式**
+
 输入一行包含一个整数n。
-#### 输出格式
+
+**输出格式**
+
 输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。
-#### 样例输入
+
+**样例输入**
+
 ```
 20
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 20 10 5 2 1
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 ```
 对于80% 的评测用例，1 < n <= 10^9。  
 对于所有评测用例，1 < n <=10^18。  

data_backup/3.蓝桥杯/181.付账问题/solution.md

 # 付账问题
 
-#### 题目描述
+
+**题目描述**
+
 几个人一起出去吃饭是常有的事。但在结帐的时候，常常会出现一些争执。
 
 现在有 n 个人出去吃饭，他们总共消费了 S 元。其中第 i 个人带了 ai 元。幸运的是，所有人带的钱的总数是足够付账的，但现在问题来了：每个人分别要出多少钱呢？
@@ -11,47 +13,65 @@
  ![参见p1.png](https://img-blog.csdnimg.cn/20201015164915888.png#pic_center)
 
 
-#### 输入格式
+
+**输入格式**
+
 从标准输入读入数据。
 
 第一行包含两个整数 n、S；  
 第二行包含 n 个非负整数 a1, …, an。
 
-#### 输出格式
+
+**输出格式**
+
 输出到标准输出。  
 
 输出最小的标准差，四舍五入保留 4 位小数。  
 保证正确答案在加上或减去 10^−9 后不会导致四舍五入的结果发生变化。  
 
-#### 样例1输入
+
+**样例1输入**
+
 ```
 5 2333
 666 666 666 666 666
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 0.0000
 ```
-#### 样例解释
+
+**样例解释**
+
 每个人都出 2333/5 元，标准差为 0。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 10 30
 2 1 4 7 4 8 3 6 4 7
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 0.7928
 ```
-#### 数据说明
+
+**数据说明**
+
 对于 10% 的数据，所有 ai 相等；  
 对于 30% 的数据，所有非 0 的 ai 相等；  
 对于 60% 的数据，n ≤ 1000；  
 对于 80% 的数据，n ≤ 10^5；  
 对于所有数据，n ≤ 5 × 10^5, 0 ≤ ai ≤ 10^9。  
 
-#### 资源约定：
+
+**资源约定：**
+
 峰值内存消耗（含虚拟机） < 256M
 CPU消耗 < 1000ms
 

data_backup/3.蓝桥杯/185.取球博弈/solution.md

 # 取球博弈
 
-#### 问题描述
+
+**问题描述**
+
 两个人玩取球的游戏。  
 一共有N个球，每人轮流取球，每次可取集合{n1,n2,n3}中的任何一个数目。  
 如果无法继续取球，则游戏结束。此时，持有奇数个球的一方获胜。如果两人都是奇数，则为平局。  
 假设双方都采用最聪明的取法，第一个取球的人一定能赢吗？  
 试编程解决这个问题。  
 
-#### 输入
+
+**输入**
+
 第一行3个正整数n1 n2 n3，空格分开，表示每次可取的数目 (0<n1,n2,n3<100)  
 第二行5个正整数x1 x2 … x5，空格分开，表示5局的初始球数(0<xi<1000)  
 
-#### 输出
+
+**输出**
+
 一行5个字符，空格分开。分别表示每局先取球的人能否获胜。  
 能获胜则输出+，  
 次之，如有办法逼平对手，输出0，  
 无论如何都会输，则输出 -  
 
-#### 输入例子 1
+
+**输入例子 1**
+
 ```
 1 2 3
 1 2 3 4 5
 ```
-#### 输出例子 1
+
+**输出例子 1**
+
 ```
 + 0 + 0 -
 ```
-#### 输入例子 2
+
+**输入例子 2**
+
 ```
 1 4 5
 10 11 12 13 15
 ```
-#### 输出例子 2
+
+**输出例子 2**
+
 ```
 0 - 0 + +
 ```
-#### 输入例子 3
+
+**输入例子 3**
+
 ```
 2 3 5
 7 8 9 10 11
 ```
-#### 输出例子 3
+
+**输出例子 3**
+
 ```
 + 0 0 0 0
 ```

data_backup/3.蓝桥杯/188.大臣的旅费/solution.md

 # 大臣的旅费
-#### 问题描述
+
+**问题描述**
+
 很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。  
 
 为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。  
@@ -10,7 +12,9 @@ J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，
 
 J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？  
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数
 
 城市从1开始依次编号，1号城市为首都。
@@ -19,10 +23,14 @@ J大臣想知道：他从某一个城市出发，中间不休息，到达另一
 
 每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。
 
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，表示大臣J最多花费的路费是多少。
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 5
 1 2 2
@@ -30,11 +38,15 @@ J大臣想知道：他从某一个城市出发，中间不休息，到达另一
 2 4 5
 2 5 4
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 135
 ```
-#### 输出格式
+
+**输出格式**
+
 ```
 大臣J从城市4到城市5要花费135的路费。
 ```

data_backup/3.蓝桥杯/25.网络分析/solution.md

 # 网络分析
 
-#### 问题描述
+
+**问题描述**
+
 小明正在做一个网络实验。
 他设置了 n 台电脑，称为节点，用于收发和存储数据。初始时，所有节点都是独立的，不存在任何连接。  
 小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。  
@@ -8,16 +10,22 @@
 一条信息只存储一次。  
 给出小明连接和测试的过程，请计算出每个节点存储信息的大小。  
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含两个整数 n, m，分别表示节点数量和操作数量。节点从1 至 n 编号。  
 接下来 m 行，每行三个整数，表示一个操作。  
 如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b时，表示连接了一个自环，对网络没有实质影响。  
 如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。  
 
-#### 输出格式
+
+**输出格式**
+
 输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行完上述操作后节点 1 至节点 n 上存储信息的大小。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 4 8
 1 1 2
@@ -29,11 +37,15 @@
 1 2 4
 2 2 1
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 13 13 5 3
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 ```
 对于 30% 的评测用例，1 ≤ n ≤ 20，1 ≤ m ≤ 100。
 对于 50% 的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 1000。

data_backup/3.蓝桥杯/27.组合数问题/solution.md

 # 组合数问题
 
-#### 问题描述
+
+**问题描述**
+
 给 n, m, k， 求有多少对(i, j)满足 1 ≤ i ≤ n, 0 ≤ j ≤ min(i, m) 且$C_i^j$≡0(mod k)，k 是质数。其中$C_i^j$是组合数，表示从 i 个不同的数中选出 j 个组成一个集合的方案数。
-#### 输入格式
+
+**输入格式**
+
 第一行两个数 t, k，其中 t 代表该测试点包含 t 组询问，k 的意思与上文中相同。
 接下来 t 行每行两个整数 n, m，表示一组询问。
-#### 输出格式
+
+**输出格式**
+
 输出 t 行，每行一个整数表示对应的答案。由于答案可能很大，请输出答案除以 109 + 7 的余数。
-#### 样例输入
+
+**样例输入**
+
 ```
 1 2
 3 3
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 1
 ```
-#### 样例说明
+
+**样例说明**
+
 在所有可能的情况中，只有 $C_2^1$ 是 2 的倍数。
-#### 样例输入
+
+**样例输入**
+
 ```
 2 5
 4 5
 6 7
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 0
 7
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 3 23
 23333333 23333333
 233333333 233333333
 2333333333 2333333333
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 851883128
 959557926
 680723120
 ```
-#### 数据规模和约定
+
+**数据规模和约定**
+
 ```
 对于所有评测用例，1 ≤ k ≤ 108, 1 ≤ t ≤ 105, 1 ≤ n, m ≤ 1018，且 k 是质数。评测时将使用 10 个评测用例测试你的程序
 ```

data_backup/3.蓝桥杯/28.分巧克力/solution.md

 # 分巧克力
+
 儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。  
 小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。  
 为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：  
@@ -7,19 +8,27 @@
 
 例如一块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
 ```

data_backup/3.蓝桥杯/30.不同子串/solution.md

 # 不同子串
-#### 题目描述
+
+**题目描述**
+
 一个字符串的非空子串是指字符串中长度至少为1 的连续的一段字符组成的串。  
 例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共7 个。  
 注意在计算时，只算本质不同的串的个数。  

data_backup/3.蓝桥杯/32.回文日期/solution.md

 # 回文日期
 
-#### 问题描述
+
+**问题描述**
+
 2020 年春节期间，有一个特殊的日期引起了大家的注意：2020年2月2日。因为如果将这个日期按“yyyymmdd” 的格式写成一个8 位数是20200202，恰好是一个回文数。我们称这样的日期是回文日期。    
 有人表示20200202 是“千年一遇” 的特殊日子。对此小明很不认同，因为不到2年之后就是下一个回文日期：20211202 即2021年12月2日。  
 也有人表示20200202 并不仅仅是一个回文日期，还是一个ABABBABA型的回文日期。对此小明也不认同，因为大约100 年后就能遇到下一个ABABBABA 型的回文日期：21211212 即2121 年12 月12 日。算不上“千年一遇”，顶多算“千年两遇”。  
 给定一个8 位数的日期，请你计算该日期之后下一个回文日期和下一个ABABBABA型的回文日期各是哪一天。
 
-#### 输入格式
+
+**输入格式**
+
 输入包含一个八位整数N，表示日期。
 
-#### 输出格式
+
+**输出格式**
+
 输出两行，每行1 个八位数。第一行表示下一个回文日期，第二行表示下
 一个ABABBABA 型的回文日期。
-#### 样例输入
+
+**样例输入**
+
 ```
 20200202
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 20211202
 21211212
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 对于所有评测用例，10000101 ≤ N ≤ 89991231，保证N 是一个合法日期的8位数表示。
 
 ## aop

data_backup/3.蓝桥杯/35.抽签/solution.md

@@ -8,16 +8,24 @@ C国最多可以派出2人。
 
 那么最终派往W星的观察团会有多少种国别的不同组合呢？
 
-#### 输入格式
+
+**输入格式**
+
 第一行N,以下N行代表N个国家最多可派出人数Ai。
-#### 输出格式
+
+**输出格式**
+
 最多多少种派法ANS，ANS为一个整数。
-#### 输出规模
+
+**输出规模**
+
 ```
 1<N<10000
 1<AI<10000
 ```
-#### 示例输入
+
+**示例输入**
+
 ```
 6
 4
@@ -27,7 +35,9 @@ C国最多可以派出2人。
 1
 3
 ```
-示例输出
+
+**示例输出**
+
 ```
 101
 ```

data_backup/3.蓝桥杯/36.波动数列/solution.md

 # 波动数列
-#### 问题描述
+
+**问题描述**
+
 观察这个数列：  
 1 3 0 2 -1 1 -2 ...  
 这个数列中后一项总是比前一项增加2或者减少3。  
 栋栋对这种数列很好奇，他想知道长度为 ```n``` 和为 ```s``` 而且后一项总是比前一项增加a或者减少b的整数数列可能有多少种呢？  
-#### 输入格式
+
+**输入格式**
+
 　　输入的第一行包含四个整数``` n s a b```，含义如前面说述。
-#### 输出格式
+
+**输出格式**
+
 　　输出一行，包含一个整数，表示满足条件的方案数。由于这个数很大，请输出方案数除以100000007的余数。
-#### 样例输入
+
+**样例输入**
+
 ```4 10 2 3```
-#### 样例输出
+
+**样例输出**
+
 ```2```
-#### 样例说明
+
+**样例说明**
+
 这两个数列分别是```2 4 1 3```和```7 4 1 -2```。
-#### 数据规模和约定
+
+**数据规模和约定**
+
 对于10%的数据，1<=n<=5，0<=s<=5，1<=a,b<=5；  
 对于30%的数据，1<=n<=30，0<=s<=30，1<=a,b<=30；  
 对于50%的数据，1<=n<=50，0<=s<=50，1<=a,b<=50；  

data_backup/3.蓝桥杯/37.糖果/solution.md

@@ -4,14 +4,20 @@
 小明希望能品尝到所有口味的糖果。遗憾的是老板并不单独出售糖果，而是K颗一包整包出售。  
 幸好糖果包装上注明了其中K颗糖果的口味，所以小明可以在买之前就知道每包内的糖果口味。  
 给定包糖果，请你计算小明最少买几包，就可以品尝到所有口味的糖果。  
-#### 输入
+
+**输入**
+
 第一行包含三个整数N、M 和K。  
 接下来N 行每行K 这整数$T_1,T_2,…,T_K$，代表一包糖果的口味。  
 1<=N<=100，1<=M<=20，1<=K<=20，1<=$T_i$<=M。  
-#### 输出
+
+**输出**
+
 一个整数表示答案。如果小明无法品尝所有口味，输出-1。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 6 5 3
 1 1 2
@@ -21,7 +27,9 @@
 5 4 2
 5 1 2
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 2
 ```

data_backup/3.蓝桥杯/38.小朋友排队/solution.md

 # 小朋友排队
 
-#### 题目描述
+
+**题目描述**
+
 n 个小朋友站成一排。
 
 现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。
@@ -15,29 +17,41 @@ n 个小朋友站成一排。
 
 如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含一个整数 n，表示小朋友的个数。
 
 第二行包含 n 个整数 H1,H2,…,Hn，分别表示每个小朋友的身高。
 
-#### 输出格式
+
+**输出格式**
+
 输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。
 
-#### 数据范围
+
+**数据范围**
+
 ```
 1≤n≤100000,
 0≤Hi≤1000000
 ```
-#### 输入样例：
+
+**输入样例：**
+
 ```
 3
 3 2 1
 ```
-#### 输出样例：
+
+**输出样例：**
+
 ```
 9
 ```
-#### 样例解释
+
+**样例解释**
+
 首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。
 
 ## aop

data_backup/3.蓝桥杯/39.灵能传输/solution.md

 # 灵能传输
 
-#### 题目背景
+
+**题目背景**
+
 在游戏《星际争霸 II》中，高阶圣堂武士作为星灵的重要 AOE 单位，在游戏的中后期发挥着重要的作用，其技能”灵能风暴“可以消耗大量的灵能对一片区域内的敌军造成毁灭性的伤害。经常用于对抗人类的生化部队和虫族的
 刺蛇飞龙等低血量单位。
-#### 问题描述
+
+**问题描述**
+
 你控制着 n 名高阶圣堂武士，方便起见标为 1,2,··· ,n。每名高阶圣堂武士需要一定的灵能来战斗，每个人有一个灵能值$a_i$表示其拥有的灵能的多少（$a_i$非负表示这名高阶圣堂武士比在最佳状态下多余了$a_i$点灵能，$a_i$为负则表示这名高阶圣堂武士还需要$-a_i$点灵能才能到达最佳战斗状态） 。现在系统赋予了你的高阶圣堂武士一个能力，传递灵能，每次你可以选择一个$ i ∈ [2,n − 1]$，若$a_i ≥ 0 $则其两旁的高阶圣堂武士，也就是$ i − 1、i + 1 $这两名高阶圣堂武士会从i 这名高阶圣堂武士这里各抽取$ a_i $点灵能；若$ a_i < 0 $则其两旁的高阶圣堂武士，也就是$ i−1,i+1 $这两名高阶圣堂武士会给 i 这名高阶圣堂武士$ −a_i $点灵能。形式化来讲就是$ a_{i-1} + = a_i ,a_{i+1} + = a_i ,a_i − = 2a_i $。  
 
 灵能是非常高效的作战工具，同时也非常危险且不稳定，一位高阶圣堂武士拥有的灵能过多或者过少都不好，定义一组高阶圣堂武士的不稳定度为$max^n_{i=1} |a_i|$，请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武士的不稳定度最小。
-#### 输入格式
+
+**输入格式**
+
 本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。  
 接下来依次输入每一组询问。  
 每组询问的第一行包含一个正整数 n，表示高阶圣堂武士的数量。  
 接下来一行包含 n 个数 $a_1 ,a_2 ,··· ,a_n $。  
-#### 输出格式
+
+**输出格式**
+
 输出 T 行。每行一个整数依次表示每组询问的答案。
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 3
@@ -24,20 +34,26 @@
 3
 1 2 3
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 3
 0
 3
 ```
-#### 样例说明
+
+**样例说明**
+
 ```
 对于第一组询问：
 对 2 号高阶圣堂武士进行传输操作后 a 1 = 3，a 2 = 2，a 3 = 1。答案为 3。
 对于第二组询问：
 这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 4
@@ -47,7 +63,9 @@
 5
 -1 -1 6 -1 -1
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 5
 7

data_backup/3.蓝桥杯/4.等差素数列/solution.md

 # 等差素数列
-#### 题目描述
+
+**题目描述**
+
 2,3,5,7,11,13,....是素数序列。
 类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
 上边的数列公差为30，长度为6。

data_backup/3.蓝桥杯/40.成绩分析/solution.md

 # 成绩分析
-#### 问题描述
+
+**问题描述**
+
 小蓝给学生们组织了一场考试，卷面总分为100分，每个学生的得分都是一个0到100的整数。
 
 请计算这次考试的最高分、最低分和平均分。
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含一个整数n，表示考试人数。
 
 接下来n行，每行包含一个0至100的整数，表示一个学生的得分。
 
-#### 输出格式
+
+**输出格式**
+
 输出三行。
 
 第一行包含一个整数，表示最高分。
@@ -18,7 +24,9 @@
 
 第三行包含一个实数，四舍五入保留正好两位小数，表示平均分。
 
-#### 样例输入
+
+**样例输入**
+
 
 ```
 7
@@ -30,7 +38,9 @@
 99
 10
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 99
 10

data_backup/3.蓝桥杯/41.乘积最大/solution.md

@@ -6,20 +6,27 @@
 请你求出最大的乘积，由于乘积可能超出整型范围，你只需输出乘积除以 1000000009 的余数。
 
 注意，如果 X<0， 我们定义 X 除以 1000000009 的余数是负(−X)除以 1000000009 的余数，即：0−((0−x)%1000000009)
-#### 输入格式
+
+**输入格式**
+
 第一行包含两个整数 N 和 K。
 
 以下 N 行每行一个整数 Ai。
 
-#### 输出格式
+**输出格式**
+
 输出一个整数，表示答案。
 
-#### 数据范围
+
+**数据范围**
+
 ```
 1≤K≤N≤105,
 −105≤Ai≤105
 ```
-#### 输入样例1：
+
+**输入样例1：**
+
 ```
 5 3
 -100000
@@ -28,11 +35,15 @@
 100000
 10000
 ```
-#### 输出样例1：
+
+**输出样例1：**
+
 ```
 999100009
 ```
-#### 输入样例2：
+
+**输入样例2：**
+
 ```
 5 3
 -100000
@@ -40,7 +51,11 @@
 -2
 -100000
 -100000
-#### 输出样例2：
+```
+
+**输出样例2：**
+
+```
 -999999829
 ```
 

data_backup/3.蓝桥杯/47.k倍区间/solution.md

 # k倍区间
 
-#### 问题描述
+
+**问题描述**
+
 给定一个长度为N的数列，$A_1, A_2, … A_N，$如果其中一段连续的子序列$A_i, A_{i+1}, … A_j(i <= j)$之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
 
 你能求出数列中总共有多少个K倍区间吗？
-#### 输入格式
+
+**输入格式**
+
 第一行包含两个整数N和K。(1 <= N, K <= 100000)  
 以下N行每行包含一个整数$A_i$。(1 <= $A_i$ <= 100000)
-#### 输出格式
+
+**输出格式**
+
 输出一个整数，代表K倍区间的数目。
-#### 样例输入
+
+**样例输入**
+
 ```
 5 2
 1
@@ -18,7 +26,9 @@
 4
 5
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 6
 ```

data_backup/3.蓝桥杯/48.压缩变换/solution.md

 # 压缩变换
 
-#### 问题描述
+
+**问题描述**
+
 小明最近在研究压缩算法。  
 他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。  
 然而，要使数值很小是一个挑战。  
@@ -15,27 +17,39 @@ a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字
 a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。  
 现在，给出原序列，请问，按这种变换规则变换后的序列是什么。  
 
-#### 输入
+
+**输入**
+
 输入第一行包含一个整数n，表示序列的长度。  
 第二行包含n个正整数，表示输入序列。  
 
-#### 输出
+
+**输出**
+
 输出一行，包含n个数，表示变换后的序列。  
 
-#### 输入例子 1
+
+**输入例子 1**
+
 ```
 5
 1 2 2 1 2
 ```
-#### 输出例子 1
+
+**输出例子 1**
+
 ```
 -1 -2 0 1 1
 ```
-#### 输入例子 2
+
+**输入例子 2**
+
 ```
 12
 ```
-#### 输出例子 2
+
+**输出例子 2**
+
 ```
 -1 0 -2 -3 1 1 2 2 0 0 2 2
 ```

data_backup/3.蓝桥杯/50.字串排序/solution.md

 # 字串排序
 
-#### 问题描述
+
+**问题描述**
+
 小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。  
 在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。  
 例如，对于字符串 lan 排序，只需要 1 次交换。对于字符串 qiao 排序，总共需要 4 次交换。  
 小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 V 次交换，可是他忘了把这个字符串记下来，现在找不到了。  
 请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对该串的字符排序，正好需要 V 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。请注意字符串中可以包含相同的字符。  
 
-#### 输入格式
+
+**输入格式**
+
 输入的第一行包含一个整数V，小蓝的幸运数字。
 
-#### 输出格式
+
+**输出格式**
+
 题面要求的一行字符串。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 4
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 bbaa
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 100
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 jihgfeeddccbbaa
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 ```
 对于 30% 的评测用例， 1 ≤ V ≤ 20。
 对于 50% 的评测用例， 1 ≤ V ≤ 100。

data_backup/3.蓝桥杯/53.等腰三角形/solution.md

@@ -11,23 +11,38 @@
 为了便于测评，我们要求空格一律用"."代替。  
 
 ### 例如：
-#### 输入：
+
+**输入：**
+
+```
 5
+```
+
+**程序应该输出：**
 
-#### 程序应该输出：
 ![](https://img-blog.csdnimg.cn/20190203175048400.png)
 
 ### 再例如：
-#### 输入：
+
+**输入：**
+
+```
 10
+```
+
+**程序应该输出：**
 
-#### 程序应该输出：
 ![](https://img-blog.csdnimg.cn/20190203175133907.png)
 ### 再例如：
-#### 输入：
+
+**输入：**
+
+```
 15
+```
+
+**程序应该输出：**
 
-#### 程序应该输出：
 ![](https://img-blog.csdnimg.cn/20190203175213126.png)
 
 

data_backup/3.蓝桥杯/54.分糖果/solution.md

 # 分糖果
-#### 问题描述
+
+**问题描述**
+
 有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏：
 每个小朋友都把自己的糖果分一半给左手边的孩子。
 一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。
 反复进行这个游戏，直到所有小朋友的糖果数都相同为止。
 你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少个糖果。
 
-#### 输入格式
+
+**输入格式**
+
 程序首先读入一个整数N(2<N<100)，表示小朋友的人数。   
 接着是一行用空格分开的N个偶数（每个偶数不大于1000，不小于2）
 
-#### 输出格式
+
+**输出格式**
+
 要求程序输出一个整数，表示老师需要补发的糖果数。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 2 2 4
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 4
 ```

data_backup/3.蓝桥杯/60.三体攻击/solution.md

 # 三体攻击
 
-#### 题目描述
+
+**题目描述**
+
 三体人将对地球发起攻击。为了抵御攻击，地球人派出了 A × B × C 艘战舰，在太空中排成一个 A 层 B 行 C 列的立方体。其中，第 i 层第 j 行第 k 列的战舰（记为战舰 (i, j, k)）的生命值为 d(i, j, k)。
 
 三体人将会对地球发起 m 轮“立方体攻击”，每次攻击会对一个小立方体中的所有战舰都造成相同的伤害。具体地，第 t 轮攻击用 7 个参数 $la_t, ra_t, lb_t, rb_t, lc_t, rc_t, h_t $描述；
@@ -8,17 +10,23 @@
 
 地球指挥官希望你能告诉他，第一艘爆炸的战舰是在哪一轮攻击后爆炸的。
 
-#### 输入格式
+
+**输入格式**
+
 从标准输入读入数据。
 第一行包括 4 个正整数 A, B, C, m；  
 第二行包含 A × B × C 个整数，其中第 ((i − 1)×B + (j − 1)) × C + (k − 1)+1 个数为 d(i, j, k)；  
 第 3 到第 m + 2 行中，第 (t − 2) 行包含 7 个正整数 $la_t, ra_t, lb_t, rb_t, lc_t, rc_t, h_t$。
 
-#### 输出格式
+
+**输出格式**
+
 输出到标准输出。
 输出第一个爆炸的战舰是在哪一轮攻击后爆炸的。保证一定存在这样的战舰。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 2 2 2 3
 1 1 1 1 1 1 1 1
@@ -26,14 +34,20 @@
 1 1 1 2 1 2 1
 1 1 1 1 1 1 2
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 2
 ```
-#### 样例解释
+
+**样例解释**
+
 在第 2 轮攻击后，战舰 (1,1,1) 总共受到了 2 点伤害，超出其防御力导致爆炸。
 
-#### 数据约定
+
+**数据约定**
+
 ```
 对于 10% 的数据，B = C = 1；
 对于 20% 的数据，C = 1；

data_backup/3.蓝桥杯/64.垒骰子/solution.md

@@ -10,32 +10,44 @@ atm想计算一下有多少种不同的可能的垒骰子方式。
 
 不要小看了 atm 的骰子数量哦～  
 
-#### 输入格式
+
+**输入格式**
+
 第一行两个整数 n m  
 n表示骰子数目  
 接下来 m 行，每行两个整数 a b ，表示 a 和 b 数字不能紧贴在一起。  
 
-#### 输出格式
+
+**输出格式**
+
 一行一个数，表示答案模 10^9 + 7 的结果。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 2 1
 1 2
 ```
-#### 样例输出 
+
+**样例输出 **
+
 ```
 544
 ```
 
-#### 数据范围
+
+**数据范围**
+
 ```
 对于 30% 的数据：n <= 5
 对于 60% 的数据：n <= 100
 对于 100% 的数据：0 < n <= 10^9, m <= 36
 ```
 
-#### 资源约定：
+
+**资源约定：**
+
 峰值内存消耗 < 256M  
 CPU消耗  < 2000ms
 

data_backup/3.蓝桥杯/68.平面切分/solution.md

 # 平面切分
 
-#### 问题描述
+
+**问题描述**
+
 平面上有 N条直线，其中第 i条直线是$ y = A_i*x + B_i$。
 
 请计算这些直线将平面分成了几个部分。
 
-#### 输入格式
+
+**输入格式**
+
 第一行包含一个整数N。
 
 以下N行，每行包含两个整数 $A_i, B_i$。
 
-#### 输出格式
+
+**输出格式**
+
 一个整数代表答案。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 1 1
 2 2
 3 3
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 6
 ```

data_backup/3.蓝桥杯/69.递增三元组/solution.md

@@ -7,7 +7,9 @@ C = [C1, C2, ... CN]，
 1. 1 <= i, j, k <= N  
 2. Ai < Bj < Ck  
 
-#### 输入格式
+
+**输入格式**
+
 第一行包含一个整数N。  
 第二行包含N个整数A1, A2, ... AN。  
 第三行包含N个整数B1, B2, ... BN。  
@@ -17,16 +19,22 @@ C = [C1, C2, ... CN]，
 对于60%的数据，1 <= N <= 1000   
 对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000   
 
-#### 输出格式
+
+**输出格式**
+
 一个整数表示答案
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 1 1 1
 2 2 2
 3 3 3
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 27
 ```

data_backup/3.蓝桥杯/70.消除尾一/solution.md

@@ -2,19 +2,27 @@
 
 下面的代码把一个整数的二进制表示的最右边的连续的1全部变成0  
 如果最后一位是0，则原数字保持不变。  
-#### 输入：
+
+**输入：**
+
 ```
 00000000000000000000000001100111
 ```
-#### 输出：
+
+**输出：**
+
 ```
 00000000000000000000000001100000
 ```
-#### 输入：
+
+**输入：**
+
 ```
 00000000000000000000000000001100
 ```
-#### 输出：
+
+**输出：**
+
 ```
 00000000000000000000000000001100
 ```

data_backup/3.蓝桥杯/72.兰顿蚂蚁/solution.md

@@ -13,14 +13,20 @@
 规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。
 蚂蚁的路线是很难事先预测的。
 你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第n步行走后所处的位置。
-#### 输入格式
+
+**输入格式**
+
 输入数据的第一行是 m n 两个整数（3 < m, n < 100），表示正方形格子的行数和列数。  
 接下来是 m 行数据。  
 每行数据为 n 个被空格分开的数字。0 表示白格，1 表示黑格。  
 接下来是一行数据：x y s k, 其中x y为整数，表示蚂蚁所在行号和列号（行号从上到下增长，列号从左到右增长，都是从0开始编号）。s 是一个大写字母，表示蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示。k 表示蚂蚁走的步数。  
-#### 输出格式
+
+**输出格式**
+
 输出数据为两个空格分开的整数 p q, 分别表示蚂蚁在k步后，所处格子的行号和列号。  
-#### 样例输入
+
+**样例输入**
+
 ```
 5 6
 0 0 0 0 0 0
@@ -30,11 +36,15 @@
 0 0 0 0 0 0
 2 3 L 5
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 1 3
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 3 3
 0 0 0
@@ -42,7 +52,9 @@
 1 1 1
 1 1 U 6
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 0 0
 ```

data_backup/3.蓝桥杯/74.字符串编码/solution.md

 # 字符串编码
 
-#### 问题描述
+
+**问题描述**
+
 小明发明了一种给由全大写字母组成的字符串编码的方法。  
 
 对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。
@@ -13,21 +15,31 @@
 
 小明希望找出其中字典序最大的字符串。
 
-#### 输入格式
+
+**输入格式**
+
 一个数字序列。
 
-#### 输出格式
+
+**输出格式**
+
 一个只包含大写字母的字符串，代表答案
 
-#### 样例输入
+
+**样例输入**
+
 ```
 123242526
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 LCXYZ
 ```
-#### 数据范围
+
+**数据范围**
+
 ```
 对于 20% 的评测用例，输入的长度不超过 20。
 对于所有评测用例，输入的长度不超过 200000。

data_backup/3.蓝桥杯/75.螺旋折线/solution.md

@@ -7,7 +7,9 @@
 
 给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？  
 
-#### 输入格式
+
+**输入格式**
+
 ```
 X和Y
 
@@ -15,15 +17,21 @@ X和Y
 对于70%的数据，-100000 <= X， Y <= 100000
 对于100%的数据, -1000000000 <= X, Y <= 1000000000
 ```
-#### 输出格式
+
+**输出格式**
+
 ```
 输出dis(X, Y)
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 0 1
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 3
 ```

data_backup/3.蓝桥杯/80.灾后重建/solution.md

 # 灾后重建
 
-#### 问题描述：
+
+**问题描述：**
+
 Pear市一共有N（<=50000）个居民点，居民点之间有M（<=200000）条双向道路相连。这些居民点两两之间都可以通过双向道路到达。这种情况一直持续到最近，一次严重的地震毁坏了全部M条道路。  
 震后，Pear打算修复其中一些道路，修理第i条道路需要Pi的时间。不过，Pear并不打算让全部的点连通，而是选择一些标号特殊的点让他们连通。  
 Pear有Q（<=50000）次询问，每次询问，他会选择所有编号在[l,r]之间，并且 编号 mod K = C 的点，修理一些路使得它们连通。由于所有道路的修理可以同时开工，所以完成修理的时间取决于花费时间最长的一条路，即涉及到的道路中Pi的最大值。  
 你能帮助Pear计算出每次询问时需要花费的最少时间么？这里询问是独立的，也就是上一个询问里的修理计划并没有付诸行动。
 
-#### 输入格式
+
+**输入格式**
+
 第一行三个正整数N、M、Q，含义如题面所述。  
 接下来M行，每行三个正整数Xi、Yi、Pi，表示一条连接Xi和Yi的双向道路，修复需要Pi的时间。可能有自环，可能有重边。1<=Pi<=1000000。
 
 接下来Q行，每行四个正整数Li、Ri、Ki、Ci，表示这次询问的点是[Li,Ri]区间中所有编号Mod Ki=Ci的点。保证参与询问的点至少有两个。
 
-#### 输出格式
+
+**输出格式**
+
 输出Q行，每行一个正整数表示对应询问的答案。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 7 10 4
 1 3 10
@@ -33,14 +41,18 @@ Pear有Q（<=50000）次询问，每次询问，他会选择所有编号在[l,r]
 2 5 1 0
 3 7 2 1
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 9
 6
 8
 8
 ```
-#### 数据范围
+
+**数据范围**
+
 对于20%的数据，N,M,Q<=30
 对于40%的数据，N,M,Q<=2000
 对于100%的数据，N<=50000,M<=2*10^5,Q<=50000. Pi<=10^6. Li,Ri,Ki均在[1,N]范围内，Ci在[0,对应询问的Ki)范围内。

data_backup/3.蓝桥杯/83.BST 插入节点问题/solution.md

 # BST 插入节点问题
 
-#### 问题描述
+
+**问题描述**
+
 给定一棵包含 N 个节点的二叉树，节点编号是 1 ∼ N。其中 i 号节点具有权值 W i ，并且这些节点的权值恰好形成了一棵排序二叉树 (BST)。  
 现在给定一个节点编号 K，小明想知道，在这 N 个权值以外，有多少个整数 X (即 X 不等于任何 W i ) 满足：给编号为 K 的节点增加一个权值为 X 的子节点，仍可以得到一棵 BST。  
 例如在下图中，括号外的数字表示编号、括号内的数字表示权值。即编号1 ∼ 4 的节点权值依次是 0、10、20、30。
@@ -11,15 +13,21 @@
 如果 K = 2，那么答案为无穷多。因为任何一个负数都可以作为 2 的左子节点。  
 如果 K = 3，那么答案为 9。因为 X = 11,12,··· ,19 都可以作为 3 的左子节点。  
 
-#### 输入格式
+
+**输入格式**
+
 第一行包含 2 个整数 N 和 K。  
 以下 N 行每行包含 2 个整数，其中第 i 行是编号为 i 的节点的父节点编号P i 和权值 W i 。注意 P i = 0 表示 i 是根节点。  
 输入保证是一棵 BST。
 
-#### 输出格式
+
+**输出格式**
+
 一个整数代表答案。如果答案是无穷多，输出 −1。  
 
-#### 样例输入
+
+**样例输入**
+
 ```
 4 3
 0 10
@@ -27,11 +35,15 @@
 1 20
 3 30
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 9
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 对于 60% 的评测用例，1 ≤ K ≤ N ≤ 100，0 ≤ W i ≤ 200，且 W i 各不相同。  
 对于所有评测用例，1 ≤ K ≤ N ≤ 10000，0 ≤ W i ≤ 100000000，且 W i 各不相同。
 

data_backup/3.蓝桥杯/86.正则问题/solution.md

 # 正则问题
 
-#### 问题描述：
+
+**问题描述：**
+
 考虑一种简单的正则表达式：只由```x()|```组成的正则表达式。  
 小明想求出这个正则表达式能接受的最长字符串的长度。  
 例如```((xx|xxx)x|(x|xx))xx``` 能接受的最长字符串是： ```xxxxxx```，长度是6。
-#### 输入格式：
+
+**输入格式：**
+
 一个由```x()|```组成的正则表达式。输入长度不超过100，保证合法。
-#### 输出格式：
+
+**输出格式：**
+
 这个正则表达式能接受的最长字符串的长度。
-#### 样例输入：
+
+**样例输入：**
+
 ```
 ((xx|xxx)x|(x|xx))xx
 ```

data_backup/3.蓝桥杯/88.次数差/solution.md

 # 次数差
-#### 问题描述
+
+**问题描述**
+
 
 x星球有26只球队，分别用 a ~ z 的26个字母代表。他们总是不停地比赛。  
 在某一赛段，哪个球队获胜了，就记录下代表它的字母，这样就形成一个长长的串。  
 国王总是询问：获胜次数最多的和获胜次数最少的有多大差距？  
 （当然，他不关心那些一次也没获胜的，认为他们在怠工罢了）  
 
-#### 输入格式
+
+**输入格式**
+
 一个串，表示球队获胜情况（保证串的长度<1000）
 
-#### 输出格式
+
+**输出格式**
+
 要求输出一个数字，表示出现次数最多的字母比出现次数最少的字母多了多少次。
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 abaabcaa
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 4
 ```
-#### 提示
+
+**提示**
+
 ```
 a 出现 5 次，最多；c 出现1次，最少。
 5 - 1 = 4
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 bbccccddaaaacccc
 ```
-#### 样例输出2
+
+**样例输出2**
+
 ```
 6
 ```

data_backup/3.蓝桥杯/92.单词分析/solution.md

 # 单词分析
-#### 问题描述
+
+**问题描述**
+
 小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。  
 现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。
-#### 输入格式
+
+**输入格式**
+
 输入一行包含一个单词，单词只由小写英文字母组成。
-#### 输出格式
+
+**输出格式**
+
 输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪
 个。如果有多个字母出现的次数相等，输出字典序最小的那个。
 第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。
-#### 样例输入
+
+**样例输入**
+
 ```
 lanqiao
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 a 2
 ```
-#### 样例输入
+
+**样例输入**
+
 ```
 longlonglongistoolong
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 o 6
 ```
-#### 评测用例规模与约定
+
+**评测用例规模与约定**
+
 对于所有的评测用例，输入的单词长度不超过 1000。
 
 

data_backup/3.蓝桥杯/93.航班时间/solution.md

 # 航班时间
 
-#### 问题背景
+
+**问题背景**
+
 
 小h前往美国参加了蓝桥杯国际赛。小h的女朋友发现小h上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。
 
@@ -8,11 +10,15 @@
 
 不久后小h的女朋友去中东交换。小h并不知道中东与北京的时差。但是小h得到了女朋友来回航班的起降时间。小h想知道女朋友的航班飞行时间是多少。
 
-#### 问题描述
+
+**问题描述**
+
 
 对于一个可能跨时区的航班，给定来回程的起降时间。假设飞机来回飞行时间相同，求飞机的飞行时间。
 
-#### 输入格式
+
+**输入格式**
+
 
 从标准输入读入数据。
 
@@ -36,7 +42,9 @@ h1:m1:s1 h2:m2:s2 或 h1:m1:s1 h3:m3:s3 (+1) 或 h1:m1:s1 h4:m4:s4 (+2)
 
 对于此题目中的所有以 h:m:s 形式给出的时间, 保证 ( 0<=h<=23, 0<=m,s<=59 ).
 
-#### 输出格式
+
+**输出格式**
+
 
 输出到标准输出。
 
@@ -44,7 +52,9 @@ h1:m1:s1 h2:m2:s2 或 h1:m1:s1 h3:m3:s3 (+1) 或 h1:m1:s1 h4:m4:s4 (+2)
 
 注意，当时间为一位数时，要补齐前导零。如三小时四分五秒应写为03:04:05。
 
-#### 样例输入
+
+**样例输入**
+
 ```
 3
 
@@ -60,7 +70,9 @@ h1:m1:s1 h2:m2:s2 或 h1:m1:s1 h3:m3:s3 (+1) 或 h1:m1:s1 h4:m4:s4 (+2)
 
 22:19:04 16:41:09 (+1)
 ```
-#### 样例输出
+
+**样例输出**
+
 ```
 04:09:05
 
@@ -68,11 +80,15 @@ h1:m1:s1 h2:m2:s2 或 h1:m1:s1 h3:m3:s3 (+1) 或 h1:m1:s1 h4:m4:s4 (+2)
 
 14:22:05
 ```
-#### 限制与约定
+
+**限制与约定**
+
 
 保证输入时间合法，飞行时间不超过24小时。
 
-#### 资源约定：
+
+**资源约定：**
+
 
 峰值内存消耗（含虚拟机）< 256M
 

data_backup/3.蓝桥杯/97.分类计数/solution.md

 # 分类计数
 
-#### 问题描述
+
+**问题描述**
+
 输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字母，多少个数字。
 
-#### 输入格式
+
+**输入格式**
+
 输入一行包含一个字符串。
 
-#### 输出格式
+
+**输出格式**
+
 输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
 
-#### 样例输入 
+
+**样例输入**
+
 ```
 1+a=Aab
 ```
-#### 样例输出 
+
+**样例输出**
+
 ```
 1 
 3 
 1
 ```
-#### 评测用例规模与约定 
+
+**评测用例规模与约定**
+
 对于所有评测用例，字符串由可见字符组成，长度不超过 100。
 
 

data_backup/3.蓝桥杯/98.翻硬币/solution.md

 # 翻硬币
-#### 问题描述
+
+**问题描述**
+
 小明正在玩一个“翻硬币”的游戏。
 
 桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
@@ -12,27 +14,39 @@
 
 我们约定：把翻动相邻的两个硬币叫做一步操作，那么要求：
 
-#### 输入格式
+
+**输入格式**
+
 两行等长的字符串，分别表示初始状态和要达到的目标状态。每行的长度<1000
 
-#### 输出格式
+
+**输出格式**
+
 一个整数，表示最小操作步数。
 
-#### 样例输入1
+
+**样例输入1**
+
 ```
 **********
 o****o****
 ```
-#### 样例输出1
+
+**样例输出1**
+
 ```
 5
 ```
-#### 样例输入2
+
+**样例输入2**
+
 ```
 *o**o***o***
 *o***o**o***
 ```
-#### 样例输出2  
+
+**样例输出2  **
+
 ```
 1
 ```

leetcode_helper.py

@@ -494,13 +494,13 @@ def add_solution_md_template_for_lanqiao():
         else:
             with open(solution_md_path, 'r', encoding='utf-8') as f:
                 solution_md_data = f.read()
-            solution_md_data = re.sub(r'#### (.*)\n', r'\*\*\1\*\*', solution_md_data)
+            solution_md_data = re.sub(r'#### (.*)\n', r'\n**\1**\n\n', solution_md_data)
+            with open(solution_md_path, 'w', encoding='utf-8') as f:
+                f.write(solution_md_data)
         
 
 
 
-
-
 if helper_function == 'count_tag_class':
     count_tag_class()
 if helper_function == 'count_exercises':
@@ -515,4 +515,6 @@ add_solution_md_template_for_lanqiao()
 
 
 # leetcode_helper_update_md()
-# leetcode_helper_update_config()
+# leetcode_helper_update_config()
\ No newline at end of file
+
+