diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/0.\345\276\256\347\224\237\347\211\251\345\242\236\346\256\226/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/0.\345\276\256\347\224\237\347\211\251\345\242\236\346\256\226/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2689cc152fd9482eb034352e0309c251b3384080
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/0.\345\276\256\347\224\237\347\211\251\345\242\236\346\256\226/solution.md"
@@ -0,0 +1,49 @@
+# 微生物增殖
+
+假设有两种微生物 X 和 Y  
+X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。  
+一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。  
+现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。  
+如果X=10，Y=90呢？  
+本题的要求就是写出这两种初始条件下，60分钟后Y的数目。  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/1.\350\243\205\351\245\260\347\217\240/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/1.\350\243\205\351\245\260\347\217\240/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0ea838db4463dc64e7e389776fbe9634ff41daa3
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/1.\350\243\205\351\245\260\347\217\240/solution.md"
@@ -0,0 +1,88 @@
+# 装饰珠
+
+#### 题目描述
+在怪物猎人这一款游戏中，玩家可以通过给装备镶嵌不同的装饰珠来获取 相应的技能，以提升自己的战斗能力。
+
+已知猎人身上一共有 6 件装备，每件装备可能有若干个装饰孔，每个装饰孔有各自的等级，可以镶嵌一颗小于等于自身等级的装饰珠 (也可以选择不镶嵌)。
+
+装饰珠有 M 种，编号 1 至 M，分别对应 M 种技能，第 i 种装饰珠的等级为 $L_i$，只能镶嵌在等级大于等于 $L_i$ 的装饰孔中。
+对第 i 种技能来说，当装备相应技能的装饰珠数量达到 $K_i$个时，会产生$W_i$($K_i$)的价值，镶嵌同类技能的数量越多，产生的价值越大，即$W_i$($K_{i-1}$)<$W_i$($K_i$)。但每个技能都有上限$P_i$(1≤$P_i$≤7)，当装备的珠子数量超过$P_i$时，只会产生$W_i$($P_i$)的价值。
+
+对于给定的装备和装饰珠数据，求解如何镶嵌装饰珠，使得 6 件装备能得到的总价值达到最大。
+
+#### 输入描述
+输入的第 1 至 6 行，包含 6 件装备的描述。其中第i行的第一个整数Ni表示第i件装备的装饰孔数量。后面紧接着Ni个整数，分别表示该装备上每个装饰孔的等级L(1≤ L ≤4)。
+第 7 行包含一个正整数 M，表示装饰珠 (技能) 种类数量。
+第 8 至 M + 7 行，每行描述一种装饰珠 (技能) 的情况。每行的前两个整数$L_j$(1≤ $L_j$ ≤4)和$P_j$(1≤ $P_j$ ≤7)分别表示第 j 种装饰珠的等级和上限。接下来$P_j$个整数，其中第 k 个数表示装备该中装饰珠数量为 k 时的价值$W_j$(k)。
+其中$1 ≤ N_i ≤ 50，1 ≤ M ≤ 10^4，1 ≤ W_j(k) ≤ 10^4。$
+
+#### 输出描述
+输出一行包含一个整数，表示能够得到的最大价值。
+#### 输入
+```
+1 1
+2 1 2
+1 1
+2 2 2
+1 1
+1 3
+3
+1 5 1 2 3 5 8
+2 4 2 4 8 15
+3 2 5 10
+```
+#### 输出
+```
+20
+```
+#### 样例说明
+按照如下方式镶嵌珠子得到最大价值 20，括号内表示镶嵌的装饰珠的种类编号：
+```
+1: (1)
+2: (1) (2)
+3: (1)
+4: (2) (2)
+5: (1)
+6: (2)
+```
+4 颗技能 1 装饰珠，4 颗技能 2 装饰珠 $W_1(4) + W_2(4) = 5 + 15 = 20。W_1(4)+W_2(4)=5+15=20$。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/10.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/10.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..db3f43e812525c9581551abfa7caf2b4b3af8a38
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/10.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.md"
@@ -0,0 +1,66 @@
+# 特别数的和
+
+#### 题目描述
+小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
+
+请问，在 1 到 n 中，所有这样的数的和是多少？
+
+#### 输入格式
+共一行，包含一个整数 n。
+
+#### 输出格式
+共一行，包含一个整数，表示满足条件的数的和。
+
+#### 数据范围
+```
+1≤n≤10000
+```
+#### 输入样例：
+```
+40
+```
+#### 输出样例：
+```
+574
+```
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/101.\350\215\222\345\262\233\346\216\242\346\265\213/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/101.\350\215\222\345\262\233\346\216\242\346\265\213/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d507547c9cbeb3015bd0b3a4a52712c977c3b9a6
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/101.\350\215\222\345\262\233\346\216\242\346\265\213/solution.md"
@@ -0,0 +1,82 @@
+# 荒岛探测
+
+科学家小蓝来到了一个荒岛，准备对这个荒岛进行探测考察。
+
+小蓝使用了一个超声定位设备来对自己进行定位。为了使用这个设备，小蓝需要在不同的点分别安装一个固定的发射器和一个固定的接收器。小蓝手中还有一个移动设备。定位设备需要从发射器发射一个信号到移动设备，移动设备收到后马上转发，最后由接收器接收，根据这些设备之间传递的时间差就能计算出移动设备距离发射器和接收器的两个距离，从而实现定位。
+
+小蓝在两个位置已经安装了发射器和接收器，其中发射器安装在坐标（$x_A$, $y_A$），接收器安装在坐标（$x_B$, $y_B$）。小蓝的发射器和接收器可能在岛上，也可能不在岛上。
+
+小蓝的定位设备设计有些缺陷，当发射器到移动设备的距离加上移动设备到接收器的距离之和大于L 时，定位设备工作不正常。当和小于等于L时，定位设备工作正常。为了安全，小蓝只在定位设备工作正常的区域探测考察。
+
+已知荒岛是一个三角形，三个顶点的坐标分别为（$x_1$, $y_1$），（$x_2$, $y_2$），（$x_3$, $y_3$）
+
+请计算，小蓝在荒岛上可以探测到的面积有多大？
+
+#### 输入格式
+输入的第一行包含五个整数，分别为 $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 $。
+
+
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/102.\346\242\205\346\243\256\347\264\240\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/102.\346\242\205\346\243\256\347\264\240\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a7cfef2dd07c80f3e693e8a1aab450f612a3b96b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/102.\346\242\205\346\243\256\347\264\240\346\225\260/solution.md"
@@ -0,0 +1,64 @@
+# 梅森素数
+
+如果一个数字的所有真因子之和等于自身，则称它为“完全数”或“完美数”
+
+例如：6 = 1 + 2 + 3
+
+28 = 1 + 2 + 4 + 7 + 14
+
+早在公元前300多年，欧几里得就给出了判定完全数的定理：
+
+若 2^n - 1 是素数，则 2^(n-1) * (2^n - 1) 是完全数。
+
+其中 ^ 表示“乘方”运算，乘方的优先级比四则运算高，例如：2^3 = 8， 2 * 2^3 = 16, 2^3-1 = 7
+
+但人们很快发现，当n很大时，判定一个大数是否为素数到今天也依然是个难题。
+
+因为法国数学家梅森的猜想，我们习惯上把形如：2^n - 1 的素数称为：梅森素数。
+
+截止2013年2月，一共只找到了48个梅森素数。 新近找到的梅森素数太大，以至于难于用一般的编程思路窥其全貌，所以我们把任务的难度降低一点：
+
+1963年，美国伊利诺伊大学为了纪念他们找到的第23个梅森素数 n=11213，在每个寄出的信封上都印上了“2^11213-1 是素数”的字样。
+
+2^11213 - 1 这个数字已经很大(有3000多位)，请你编程求出这个素数的十进制表示的最后100位。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/103.\344\271\260\344\270\215\345\210\260\347\232\204\346\225\260\347\233\256/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/103.\344\271\260\344\270\215\345\210\260\347\232\204\346\225\260\347\233\256/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..85b34946a52460ee8b78499cd90ac6ff8fed953b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/103.\344\271\260\344\270\215\345\210\260\347\232\204\346\225\260\347\233\256/solution.md"
@@ -0,0 +1,76 @@
+# 买不到的数目
+
+#### 问题描述
+
+小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。
+
+小朋友来买糖的时候，他就用这两种包装来组合。当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。
+
+你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。大于17的任何数字都可以用4和7组合出来。
+
+本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。
+
+#### 输入格式
+
+两个正整数，表示每种包装中糖的颗数(都不多于1000)
+
+#### 输出格式
+
+一个正整数，表示最大不能买到的糖数
+
+#### 样例输入1
+```
+4 7
+```
+#### 样例输出1
+```
+17
+```
+#### 样例输入2
+```
+3 5
+```
+#### 样例输出2
+```
+7
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/105.\347\273\204\351\230\237/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/105.\347\273\204\351\230\237/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cd7f95c4c039fc5d78acb9b61f2f18055c798131
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/105.\347\273\204\351\230\237/solution.md"
@@ -0,0 +1,45 @@
+# 组队
+
+作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。 每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少？
+
+![](https://img-blog.csdnimg.cn/20200328201519748.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxMDMyMA==,size_16,color_FFFFFF,t_70#pic_center)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/107.\346\227\242\347\272\246\345\210\206\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/107.\346\227\242\347\272\246\345\210\206\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6924838e5f561aa07f41cc5ba0ceb2b84ffcfb0c
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/107.\346\227\242\347\272\246\345\210\206\346\225\260/solution.md"
@@ -0,0 +1,45 @@
+# 既约分数
+
+如果一个分数的分子和分母的最大公约数是 1，这个分数称为既约分数。  
+例如，3/4 , 2/5, 1/8 , 1/7 都是既约分数。  
+请问，有多少个既约分数，分子和分母都是 1 到 2020 之间的整数（包括 1 和 2020）？  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/108.\351\253\230\346\226\257\346\227\245\350\256\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/108.\351\253\230\346\226\257\346\227\245\350\256\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4dfec742cbc21e2e97cb5d32fa3b571f1a4127f3
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/108.\351\253\230\346\226\257\346\227\245\350\256\260/solution.md"
@@ -0,0 +1,61 @@
+# 高斯日记
+
+大数学家高斯有个好习惯：无论如何都要记日记。
+
+他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210
+
+
+后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？
+
+
+高斯出生于：1777年4月30日。
+
+在高斯发现的一个重要定理的日记上标注着：5343，因此可算出那天是：1791年12月15日。
+
+
+高斯获得博士学位的那天日记上标着：8113   
+
+
+请你算出高斯获得博士学位的年月日。
+#### 输出格式
+提交答案的格式是：yyyy-mm-dd, 例如：1980-03-21
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/109.\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/109.\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..987a095e3c97583a798e1bf70ec8708546c1c0f6
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/109.\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/solution.md"
@@ -0,0 +1,70 @@
+# 后缀表达式
+
+#### 问题描述
+
+给定 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。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/11.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/11.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0713c2d4e94e0a5ebe744bbd483bd3300b6120f7
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/11.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.md"
@@ -0,0 +1,57 @@
+# 逆波兰表达式
+
+正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。  
+例如：3 + 5 * (2 + 6) - 1  
+而且，常常需要用括号来改变运算次序。  
+相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：  
+```
+- + 3 * 5 + 2 6 1
+```
+不再需要括号，机器可以用递归的方法很方便地求解。
+为了简便，我们假设：
+1. 只有 $ + - * $ 三种运算符
+2. 每个运算数都是一个小于10的非负整数  
+
+下面的程序对一个逆波兰表示串进行求值。  
+其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。 
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/110.\345\244\215\346\225\260\345\271\202/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/110.\345\244\215\346\225\260\345\271\202/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5d0cc3437162abe76f53dfd3628128014b013f69
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/110.\345\244\215\346\225\260\345\271\202/solution.md"
@@ -0,0 +1,49 @@
+# 复数幂
+
+设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。  
+求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
+
+答案写成 "实部±虚部i" 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。  
+(2+3i)^2 写成: -5+12i，  
+(2+3i)^5 写成: 122-597i
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/111.\344\270\211\347\276\212\347\214\256\347\221\236/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/111.\344\270\211\347\276\212\347\214\256\347\221\236/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..44ffae35493e853e360345438db90e5f5a7f32bc
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/111.\344\270\211\347\276\212\347\214\256\347\221\236/solution.md"
@@ -0,0 +1,48 @@
+# 三羊献瑞
+
+观察下面的加法算式：
+
+![](https://img-blog.csdnimg.cn/20200323231451860.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxMDMyMA==,size_16,color_FFFFFF,t_70#pic_center)
+
+其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。  
+请你填写“三羊献瑞”所代表的4位数字（答案唯一）
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/113.\345\211\252\351\202\256\347\245\250/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/113.\345\211\252\351\202\256\347\245\250/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4888125abf7406b3c8e2167bd7e31ef74bfa4d24
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/113.\345\211\252\351\202\256\347\245\250/solution.md"
@@ -0,0 +1,51 @@
+# 剪邮票
+
+如图  
+![](https://img-blog.csdnimg.cn/20190313183756434.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N5bHZpYV9XdTUx,size_16,color_FFFFFF,t_70)  
+有12张连在一起的12生肖的邮票。  
+现在你要从中剪下5张来，要求必须是连着的。  
+（仅仅连接一个角不算相连）比如  
+![](https://img-blog.csdnimg.cn/20190313183806622.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N5bHZpYV9XdTUx,size_16,color_FFFFFF,t_70)，
+![](https://img-blog.csdnimg.cn/2019031318382071.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N5bHZpYV9XdTUx,size_16,color_FFFFFF,t_70)中，粉红色所示部分就是合格的剪取。
+
+请你计算，一共有多少种不同的剪取方法。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/115.\346\211\213\351\223\276\346\240\267\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/115.\346\211\213\351\223\276\346\240\267\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9ea65b03aeccfb281d1e81874a458ccc67046ed5
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/115.\346\211\213\351\223\276\346\240\267\345\274\217/solution.md"
@@ -0,0 +1,45 @@
+# 手链样式
+
+小明有3颗红珊瑚，4颗白珊瑚，5颗黄玛瑙。  
+他想用它们串成一圈作为手链，送给女朋友。  
+现在小明想知道：如果考虑手链可以随意转动或翻转，一共可以有多少不同的组合样式呢？  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/116.\345\255\220\344\270\262\345\210\206\345\200\274/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/116.\345\255\220\344\270\262\345\210\206\345\200\274/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e66ceb838a8180ba9872e78912a96f7f86ae064d
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/116.\345\255\220\344\270\262\345\210\206\345\200\274/solution.md"
@@ -0,0 +1,90 @@
+# 子串分值
+
+#### 题目描述
+对于一个字符串 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
+```
+样例解释
+```
+子串 f值
+a     1
+ab    2
+aba   1
+abab  0
+ababc 1
+ b    1
+ ba   2
+ bab  1
+ babc 2
+  a   1
+  ab  2
+  abc 3
+   b  1
+   bc 2
+    c 1
+```
+数据范围
+```
+对于 20% 的评测用例，1 ≤ n ≤ 10 1 ≤ n ≤ 101≤n≤10；
+对于 40% 的评测用例，1 ≤ n ≤ 100 1 ≤ n ≤ 1001≤n≤100；
+对于 50% 的评测用例，1 ≤ n ≤ 1000 1 ≤ n ≤ 10001≤n≤1000；
+对于 60% 的评测用例，1 ≤ n ≤ 10000 1 ≤ n ≤ 100001≤n≤10000；
+对于所有评测用例，1 ≤ n ≤ 100000 1 ≤ n ≤ 1000001≤n≤100000。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/118.\345\205\250\347\220\203\345\217\230\346\232\226/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/118.\345\205\250\347\220\203\345\217\230\346\232\226/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..028c77d49f70ea3e033227c4cc96bc6059de94f6
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/118.\345\205\250\347\220\203\345\217\230\346\232\226/solution.md"
@@ -0,0 +1,118 @@
+# 全球变暖
+
+你有一张某海域 N×N 像素的照片，”.”表示海洋、”#”表示陆地，如下所示：
+```
+.......
+.##....
+.##....
+....##.
+..####.
+...###.
+.......
+```
+其中”上下左右”四个方向上连在一起的一片陆地组成一座岛屿，例如上图就有 2 座岛屿。
+
+由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。
+
+具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
+
+例如上图中的海域未来会变成如下样子：
+```
+.......
+.......
+.......
+.......
+....#..
+.......
+.......
+```
+请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
+
+#### 输入格式
+第一行包含一个整数N。
+
+以下 N 行 N 列，包含一个由字符”#”和”.”构成的 N×N 字符矩阵，代表一张海域照片，”#”表示陆地，”.”表示海洋。
+
+照片保证第 1 行、第 1 列、第 N 行、第 N 列的像素都是海洋。
+
+#### 输出格式
+一个整数表示答案。
+
+#### 数据范围
+```
+1≤N≤1000
+```
+#### 输入样例1：
+```
+7
+.......
+.##....
+.##....
+....##.
+..####.
+...###.
+.......
+```
+#### 输出样例1：
+```
+1
+```
+#### 输入样例2：
+```
+9
+.........
+.##.##...
+.#####...
+.##.##...
+.........
+.##.#....
+.#.###...
+.#..#....
+.........
+```
+#### 输出样例2：
+```
+1
+```
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/119.\350\265\260\346\226\271\346\240\274/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/119.\350\265\260\346\226\271\346\240\274/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2838522b224d13e7cfe53e6bcf930676aea8b840
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/119.\350\265\260\346\226\271\346\240\274/solution.md"
@@ -0,0 +1,70 @@
+# 走方格
+
+#### 问题描述
+在平面上有一些二维的点阵。这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下走。注意，如果行号和列数都是偶数，不能走入这一格中。问有多少种方案。
+
+#### 输入格式
+输入一行包含两个整数 n, m。
+
+#### 输出格式
+输出一个整数，表示答案。
+
+#### 样例输入
+```
+3 4
+```
+#### 样例输出
+```
+2
+```
+#### 样例输入
+```
+6 6
+```
+#### 样例输出
+```
+0
+```
+#### 测试数据
+对于所有评测用例，1 ≤ n ≤ 30, 1 ≤ m ≤ 30。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/12.\346\235\216\347\231\275\346\211\223\351\205\222/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/12.\346\235\216\347\231\275\346\211\223\351\205\222/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a7a4692e9a70434411f0974d34123f4310395f11
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/12.\346\235\216\347\231\275\346\211\223\351\205\222/solution.md"
@@ -0,0 +1,49 @@
+# 李白打酒
+
+话说大诗人李白，一生好饮。幸好他从不开车。  
+一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：  
+无事街上走，提壶去打酒。  
+逢店加一倍，遇花喝一斗。  
+这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。   
+请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/122.\344\270\226\347\272\252\346\234\253\347\232\204\346\230\237\346\234\237/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/122.\344\270\226\347\272\252\346\234\253\347\232\204\346\230\237\346\234\237/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..50c9a957a373935e9eb0108375411eea7061b9e9
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/122.\344\270\226\347\272\252\346\234\253\347\232\204\346\230\237\346\234\237/solution.md"
@@ -0,0 +1,54 @@
+# 世纪末的星期
+
+曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。
+
+还有人称今后的某个世纪末的12月31日，如果是星期一则会....
+
+有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!! 
+
+于是，“谣言制造商”又修改为星期日......
+
+1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？
+
+请回答该年份（只写这个4位整数，不要写12月31等多余信息）
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/123.\344\270\211\351\203\250\346\216\222\345\272\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/123.\344\270\211\351\203\250\346\216\222\345\272\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..81859ef6b280e83a1c7c4fefb1bd047bd77b7c23
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/123.\344\270\211\351\203\250\346\216\222\345\272\217/solution.md"
@@ -0,0 +1,52 @@
+# 三部排序
+
+一般的排序有许多经典算法，如快速排序、希尔排序等。但实际应用时，经常会或多或少有一些特殊的要求。我们没必要套用那些经典算法，可以根据实际情况建立更好的解法。
+
+比如，对一个整型数组中的数字进行分类排序：
+
+使得负数都靠左端，正数都靠右端，0在中部。注意问题的特点是：负数区域和正数区域内并不要求有序。可以利用这个特点通过1次线性扫描就结束战斗!!
+
+以下的程序实现了该目标。
+
+其中x指向待排序的整型数组，len是数组的长度。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/125.\347\214\264\345\255\220\345\210\206\351\246\231\350\225\211/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/125.\347\214\264\345\255\220\345\210\206\351\246\231\350\225\211/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5e9bae1a7563b8d683cba2c4312e4bb26f5a5973
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/125.\347\214\264\345\255\220\345\210\206\351\246\231\350\225\211/solution.md"
@@ -0,0 +1,50 @@
+# 猴子分香蕉
+
+5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。  
+第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。  
+第2只猴子醒来，重新把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。  
+第3只猴子醒来，重新把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。  
+第4只猴子醒来，重新把香蕉均分成5堆，还剩下4个，就吃掉并把自己的一份藏起来继续睡觉。  
+第5只猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！  
+请计算一开始最少有多少个香蕉。
+ 
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/127.\350\247\243\345\257\206/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/127.\350\247\243\345\257\206/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0c9b1a40bf4dd574327409d5ab693f29e6a63e9e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/127.\350\247\243\345\257\206/solution.md"
@@ -0,0 +1,53 @@
+# 解密
+
+#### 问题描述
+RSA 是一种经典的加密算法。它的基本加密过程如下。  
+首先生成两个质数 p, q，令 n = p · q，设 d 与 (p − 1) · (q − 1) 互质，则可找到 e 使得 d · e 除 (p − 1) · (q − 1) 的余数为 1。
+n, d, e 组成了私钥，n, d 组成了公钥。  
+当使用公钥加密一个整数 X 时（小于 n），计算 C = Xd mod n，则 C 是加密后的密文。  
+当收到密文 C 时，可使用私钥解开，计算公式为 X = Ce mod n。  
+例如，当 p = 5, q = 11, d = 3 时，n = 55, e = 27。  
+若加密数字 24，得 243 mod 55 = 19。  
+解密数字 19，得 1927 mod 55 = 24。  
+现在你知道公钥中 n = 1001733993063167141, d = 212353，同时你截获了别人发送的密文 C = 20190324，请问，原文是多少？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/128.\344\270\211\350\247\222\345\275\242\351\235\242\347\247\257/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/128.\344\270\211\350\247\222\345\275\242\351\235\242\347\247\257/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e9263cb2929df5e35afd2a93fdd2e016f860839b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/128.\344\270\211\350\247\222\345\275\242\351\235\242\347\247\257/solution.md"
@@ -0,0 +1,49 @@
+# 三角形面积
+
+已知三角形三个顶点在直角坐标系下的坐标分别为：
+```
+（2.3,2.5）
+（6.4,3.1）
+（5.1,7.2）
+```
+求该三角形的面积。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/129.\346\225\260\345\210\227\346\261\202\345\200\274/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/129.\346\225\260\345\210\227\346\261\202\345\200\274/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ed4b2754be11938010e2bc7c4bfe2ad76eb15624
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/129.\346\225\260\345\210\227\346\261\202\345\200\274/solution.md"
@@ -0,0 +1,43 @@
+# 数列求值
+
+给定数列1, 1, 1, 3, 5, 9, 17, …，从第4 项开始，每项都是前3 项的和。求第20190324 项的最后4 位数字。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/13.\350\277\267\345\256\253/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/13.\350\277\267\345\256\253/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b680fc378940c77362bf14615b69d437e63d0c33
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/13.\350\277\267\345\256\253/solution.md"
@@ -0,0 +1,86 @@
+# 迷宫
+
+#### 问题描述
+下图给出了一个迷宫的平面图，其中标记为 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
+
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/130.\344\271\235\346\225\260\347\273\204\345\210\206\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/130.\344\271\235\346\225\260\347\273\204\345\210\206\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8857022f2aa4276d021c654892bcf3b2d5ea4639
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/130.\344\271\235\346\225\260\347\273\204\345\210\206\346\225\260/solution.md"
@@ -0,0 +1,43 @@
+# 九数组分数
+
+1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/131.\346\234\200\345\244\247\346\257\224\344\276\213/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/131.\346\234\200\345\244\247\346\257\224\344\276\213/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f3de934ea21599a015696876dc15f048dffde581
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/131.\346\234\200\345\244\247\346\257\224\344\276\213/solution.md"
@@ -0,0 +1,97 @@
+# 最大比例
+
+X星球的某个大奖赛设了 M 级奖励。
+
+每个级别的奖金是一个正整数。
+
+并且，相邻的两个级别间的比例是个固定值。
+
+也就是说：所有级别的奖金数构成了一个等比数列。
+
+比如：16,24,36,54，其等比值为：3/2。
+
+现在，我们随机调查了一些获奖者的奖金数。
+
+请你据此推算可能的最大的等比值。
+
+#### 输入格式
+第一行为数字 N ，表示接下的一行包含 N 个正整数。
+
+第二行 N 个正整数 Xi，用空格分开，每个整数表示调查到的某人的奖金数额。
+
+#### 输出格式
+一个形如 A/B 的分数，要求 A、B 互质，表示可能的最大比例系数。
+
+#### 数据范围
+
+$0< N < 100$  
+$0 < X_i < 10^12$  
+数据保证一定有解。
+
+#### 输入样例1：
+```
+3
+1250 200 32
+```
+#### 输出样例1：
+```
+25/4
+```
+#### 输入样例2：
+```
+4
+3125 32 32 200
+```
+#### 输出样例2：
+```
+5/2
+```
+#### 输入样例3：
+```
+3
+549755813888 524288 2
+```
+#### 输出样例3：
+```
+4/1
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/132.\346\225\260\345\255\227\344\270\211\350\247\222\345\275\242/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/132.\346\225\260\345\255\227\344\270\211\350\247\222\345\275\242/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0f0fd6930ba2fe0659a2c1968c895254b0c31621
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/132.\346\225\260\345\255\227\344\270\211\350\247\222\345\275\242/solution.md"
@@ -0,0 +1,81 @@
+# 数字三角形
+
+#### 题目描述
+
+![](https://img-blog.csdnimg.cn/20210330204547371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjIzOTM3MA==,size_16,color_FFFFFF,t_70)
+
+上图给出了一个数字三角形。
+
+从三角形的顶部到底部有很多条不同的路径。
+
+对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。
+
+路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右边的那个数。
+
+此外，向左下走的次数与向右下走的次数相差不能超过 1。
+
+#### 输入格式
+输入的第一行包含一个整数 N，表示三角形的行数。  
+下面的 N 行给出数字三角形。  
+数字三角形上的数都是 0 至 100 之间的整数。  
+
+#### 输出格式
+输出一个整数，表示答案。
+
+#### 输入样例
+```
+5
+7
+3 8
+8 1 0
+2 7 4 4
+4 5 2 6 5
+```
+#### #### 输出样例
+```
+27
+```
+数据范围
+```
+1 ≤ N ≤ 100
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/133.\347\273\263\345\234\210/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/133.\347\273\263\345\234\210/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..21bc183cf3d9abc5dfb12dcce6b1dc3f55f03911
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/133.\347\273\263\345\234\210/solution.md"
@@ -0,0 +1,45 @@
+# 绳圈
+
+今有 100 根绳子，当然会有 200 个绳头。  
+如果任意取绳头两两配对，把所有绳头都打结连接起来。最后会形成若干个绳圈（不考虑是否套在一起）。      
+我们的问题是：请计算最后将形成多少个绳圈的概率最大？  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/136.\346\227\245\346\234\237\351\227\256\351\242\230/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/136.\346\227\245\346\234\237\351\227\256\351\242\230/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6de34bdbbe6b6927be7304d4ae13bd5312d0a07a
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/136.\346\227\245\346\234\237\351\227\256\351\242\230/solution.md"
@@ -0,0 +1,67 @@
+# 日期问题
+
+小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。  
+ 
+比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。  
+ 
+给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
+ 
+#### 输入
+
+一个日期，格式是"AA/BB/CC"。  (0 <= A, B, C <= 9)  
+ 
+#### 输出
+
+输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。  
+ 
+#### 样例输入
+```
+02/03/04  
+```
+#### 样例输出
+```
+2002-03-04  
+2004-02-03  
+2004-03-02  
+```
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/138.\347\206\212\346\200\252\345\220\203\346\240\270\346\241\203/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/138.\347\206\212\346\200\252\345\220\203\346\240\270\346\241\203/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..97e175ae53d7a62a2a640dcb6fed96522ef40053
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/138.\347\206\212\346\200\252\345\220\203\346\240\270\346\241\203/solution.md"
@@ -0,0 +1,45 @@
+# 熊怪吃核桃
+
+森林里有一只熊怪，很爱吃核桃。不过它有个习惯，每次都把找到的核桃分成相等的两份，吃掉一份，留一份。  
+如果不能等分，熊怪就会扔掉一个核桃再分。第二天再继续这个过程，直到最后剩一个核桃了，直接丢掉。  
+有一天，熊怪发现了1543个核桃，请问，它在吃这些核桃的过程中，一共要丢掉多少个核桃？  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/139.\351\245\256\346\226\231\346\215\242\350\264\255/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/139.\351\245\256\346\226\231\346\215\242\350\264\255/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b7a627fde888a4c3f3428ae6bbab68a1dc85c46e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/139.\351\245\256\346\226\231\346\215\242\350\264\255/solution.md"
@@ -0,0 +1,66 @@
+# 饮料换购
+
+乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去(但不允许暂借或赊账)。  
+
+请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能喝到多少瓶饮料。  
+
+输入：一个整数n，表示开始购买的饮料数量（0<n<10000）  
+输出：一个整数，表示实际得到的饮料数  
+
+例如：  
+用户输入：  
+```
+100
+```
+程序应该输出：  
+```
+149
+```
+用户输入：
+```
+101
+```
+程序应该输出：
+```
+151
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/140.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\346\235\203\345\200\274/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/140.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\346\235\203\345\200\274/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ed9a6614a9a539eb4f14f4ebda379bdc10921d90
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/140.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\346\235\203\345\200\274/solution.md"
@@ -0,0 +1,67 @@
+# 完全二叉树的权值
+
+#### 问题描述
+给定一棵包含 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)
+
+现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点  
+权值之和最大？如果有多个深度的权值和同为最大，请你输出其中最小的深度。  
+
+**注：根的深度是 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。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/141.\347\211\214\345\236\213\347\247\215\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/141.\347\211\214\345\236\213\347\247\215\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c5552d0b6cc04efdd6f9df4069d94f1c14c24bd3
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/141.\347\211\214\345\236\213\347\247\215\346\225\260/solution.md"
@@ -0,0 +1,49 @@
+# 牌型种数
+
+
+小明被劫持到X赌城，被迫与其他3人玩牌。  
+一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。  
+这时，小明脑子里突然冒出一个问题：  
+如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/142.\345\225\244\351\205\222\345\222\214\351\245\256\346\226\231/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/142.\345\225\244\351\205\222\345\222\214\351\245\256\346\226\231/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..48cdda8394dd8c35f7d88688e074c62f66e46b2d
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/142.\345\225\244\351\205\222\345\222\214\351\245\256\346\226\231/solution.md"
@@ -0,0 +1,44 @@
+# 啤酒和饮料
+
+啤酒每罐2.3元，饮料每罐1.9元。小明买了若干啤酒和饮料，一共花了82.3元。  
+我们还知道他买的啤酒比饮料的数量少，请你计算他买了几罐啤酒。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/144.\347\237\251\351\230\265\347\277\273\347\241\254\345\270\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/144.\347\237\251\351\230\265\347\277\273\347\241\254\345\270\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..248fd84a0792660979de52f35c926f57dab814d1
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/144.\347\237\251\351\230\265\347\277\273\347\241\254\345\270\201/solution.md"
@@ -0,0 +1,67 @@
+# 矩阵翻硬币
+
+#### 问题描述
+小明先把硬币摆成了一个 n 行 m 列的矩阵。  
+随后，小明对每一个硬币分别进行一次 Q 操作。  
+对第x行第y列的硬币进行 Q 操作的定义：将所有第 $i*x$ 行，第 $j*y$ 列的硬币进行翻转。  
+其中i和j为任意使操作可行的正整数，行号和列号都是从1开始。  
+当小明对所有硬币都进行了一次 Q 操作后，他发现了一个奇迹——所有硬币均为正面朝上。  
+小明想知道最开始有多少枚硬币是反面朝上的。于是，他向他的好朋友小M寻求帮助。  
+聪明的小M告诉小明，只需要对所有硬币再进行一次Q操作，即可恢复到最开始的状态。然而小明很懒，不愿意做。于是小明希望你给出他更好的方法。帮他计算出答案。  
+#### 输入格式
+输入数据包含一行，两个正整数 n m，含义见题目描述。
+#### 输出格式
+输出一个正整数，表示最开始有多少枚硬币是反面朝上的。
+#### 样例输入
+```
+2 3
+```
+#### 样例输出
+```
+1
+```
+#### 数据规模和约定
+对于10%的数据，n、m <= 10^3；  
+对于20%的数据，n、m <= 10^7；  
+对于40%的数据，n、m <= 10^15；  
+对于10%的数据，n、m <= 10^1000（10的1000次方）。  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/145.\345\217\262\344\270\260\346\224\266\351\200\237\347\256\227/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/145.\345\217\262\344\270\260\346\224\266\351\200\237\347\256\227/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..28f10711c0452bb783ae3314092e0a75041ceb71
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/145.\345\217\262\344\270\260\346\224\266\351\200\237\347\256\227/solution.md"
@@ -0,0 +1,59 @@
+# 史丰收速算
+
+史丰收速算法的革命性贡献是：从高位算起，预测进位。不需要九九表，彻底颠覆了传统手算!  
+速算的核心基础是：1位数乘以多位数的乘法。  
+其中，乘以7是最复杂的，就以它为例。  
+因为，1/7 是个循环小数：0.142857...，如果多位数超过 142857...，就要进1  
+同理，2/7, 3/7, ... 6/7 也都是类似的循环小数，多位数超过 n/7，就要进n  
+下面的程序模拟了史丰收速算法中乘以7的运算过程。  
+乘以 7 的个位规律是：偶数乘以2，奇数乘以2再加5，都只取个位。  
+乘以 7 的进位规律是：  
+```
+满 142857... 进1,
+满 285714... 进2,
+满 428571... 进3,
+满 571428... 进4,
+满 714285... 进5,
+满 857142... 进6
+```
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/146.\347\224\237\345\221\275\344\271\213\346\240\221/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/146.\347\224\237\345\221\275\344\271\213\346\240\221/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8d8b10776e111096280f14feb16cf5c0d509a867
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/146.\347\224\237\345\221\275\344\271\213\346\240\221/solution.md"
@@ -0,0 +1,90 @@
+# 生命之树
+
+在X森林里，上帝创建了生命之树。
+
+他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。
+
+上帝要在这棵树内选出一个非空节点集 S，使得对于 S 中的任意两个点 a,b都存在一个点列 {a,v1,v2,…,vk,b} 使得这个点列中的每个点都是 S 里面的元素，且序列中相邻两个点间有一条边相连。
+
+在这个前提下，上帝要使得 S 中的点所对应的整数的和尽量大。
+
+这个最大的和就是上帝给生命之树的评分。
+
+经过 atm 的努力，他已经知道了上帝给每棵树上每个节点上的整数。
+
+但是由于 atm 不擅长计算，他不知道怎样有效的求评分。
+
+他需要你为他写一个程序来计算一棵树的分数。
+
+#### 输入格式
+第一行一个整数 n 表示这棵树有 n 个节点。
+
+第二行 n 个整数，依次表示每个节点的评分。
+
+接下来 n−1 行，每行 2 个整数 u,v，表示存在一条 u 到 v 的边。
+
+由于这是一棵树，所以是不存在环的。
+
+树的节点编号从 1 到 n。
+
+#### 输出格式
+输出一行一个数，表示上帝给这棵树的分数。
+
+#### 数据范围
+```
+1≤n≤105,
+每个节点的评分的绝对值均不超过 10的6次方。
+```
+#### 输入样例：
+```
+5
+1 -2 -3 4 5
+4 2
+3 1
+1 2
+2 5
+```
+#### 输出样例：
+```
+8
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/147.\350\232\202\350\232\201\346\204\237\345\206\222/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/147.\350\232\202\350\232\201\346\204\237\345\206\222/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2de0d1fae32ed5d5a57f3dabeb46167339aa3cdd
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/147.\350\232\202\350\232\201\346\204\237\345\206\222/solution.md"
@@ -0,0 +1,92 @@
+# 蚂蚁感冒
+
+#### 题目描述
+长 100 厘米的细长直杆子上有 n 只蚂蚁。
+
+它们的头有的朝左，有的朝右。
+
+每只蚂蚁都只能沿着杆子向前爬，速度是 1 厘米/秒。
+
+当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。
+
+这些蚂蚁中，有 1 只蚂蚁感冒了。
+
+并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。
+
+请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。
+
+#### 输入格式
+第一行输入一个整数 n, 表示蚂蚁的总数。
+
+接着的一行是 n 个用空格分开的整数 Xi, Xi 的绝对值表示蚂蚁离开杆子左边端点的距离。
+
+正值表示头朝右，负值表示头朝左，数据中不会出现 0 值，也不会出现两只蚂蚁占用同一位置。
+
+其中，第一个数据代表的蚂蚁感冒了。
+
+#### 输出格式
+输出1个整数，表示最后感冒蚂蚁的数目。
+
+#### 数据范围
+```
+1<n<50,
+0<|Xi|<100
+```
+#### 输入样例1：
+```
+3
+5 -2 8
+```
+#### 输出样例1：
+```
+1
+```
+#### 输入样例2：
+```
+5
+-10 8 -20 12 25
+```
+#### 输出样例2：
+```
+3
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/148.\350\264\255\347\211\251\345\215\225/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/148.\350\264\255\347\211\251\345\215\225/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cb828ae55b580e6114acd5ce06f22dc4fd82470c
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/148.\350\264\255\347\211\251\345\215\225/solution.md"
@@ -0,0 +1,103 @@
+# 购物单
+
+小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。你的任务是计算出，小明最少需要取多少现金。
+
+```
+以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
+-----------------
+****     180.90       88折
+****      10.25       65折
+****      56.14        9折
+****     104.65        9折
+****     100.30       88折
+****     297.15        半价
+****      26.75       65折
+****     130.62        半价
+****     240.28       58折
+****     270.62        8折
+****     115.87       88折
+****     247.34       95折
+****      73.21        9折
+****     101.00        半价
+****      79.54        半价
+****     278.44        7折
+****     199.26        半价
+****      12.97        9折
+****     166.30       78折
+****     125.50       58折
+****      84.98        9折
+****     113.35       68折
+****     166.57        半价
+****      42.56        9折
+****      81.90       95折
+****     131.78        8折
+****     255.89       78折
+****     109.17        9折
+****     146.69       68折
+****     139.33       65折
+****     141.16       78折
+****     154.74        8折
+****      59.42        8折
+****      85.44       68折
+****     293.70       88折
+****     261.79       65折
+****      11.30       88折
+****     268.27       58折
+****     128.29       88折
+****     251.03        8折
+****     208.39       75折
+****     128.88       75折
+****      62.06        9折
+****     225.87       75折
+****      12.89       75折
+****      34.28       75折
+****      62.16       58折
+****     129.12        半价
+****     218.37        半价
+****     289.69        8折
+--------------------
+```
+需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。  
+特别地，半价是按50%计算。  
+请提交小明要从取款机上提取的金额，单位是元。  
+答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/15.\345\210\207\351\235\242\346\235\241/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/15.\345\210\207\351\235\242\346\235\241/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6f52a4d03e2ef276bcb180b59afa8a3d041f1af9
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/15.\345\210\207\351\235\242\346\235\241/solution.md"
@@ -0,0 +1,46 @@
+# 切面条
+
+一根高筋拉面，中间切一刀，可以得到2根面条。  
+如果先对折1次，中间切一刀，可以得到3根面条。  
+如果连续对折2次，中间切一刀，可以得到5根面条。  
+那么，连续对折10次，中间切一刀，会得到多少面条呢？      
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/150.\345\211\252\346\240\274\345\255\220/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/150.\345\211\252\346\240\274\345\255\220/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7cc6478644ade695305d73bf34567c3f8f13bb1c
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/150.\345\211\252\346\240\274\345\255\220/solution.md"
@@ -0,0 +1,92 @@
+# 剪格子
+
+#### 问题描述
+如下图所示，3 x 3 的格子中填写了一些整数。  
+```
++--*--+--+
+|10* 1|52|
++--****--+
+|20|30* 1|
+*******--+
+| 1| 2| 3|
++--+--+--+  
+```
+我们沿着图中的星号线剪开，得到两个部分，每个部分的数字和都是60。
+
+本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。
+
+如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
+
+如果无法分割，则输出 0。
+
+#### 输入格式
+程序先读入两个整数 m n 用空格分割 (m,n<10)。
+
+表示表格的宽度和高度。
+
+接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000。
+
+#### 输出格式
+输出一个整数，表示在所有解中，包含左上角的分割区可能包含的最小的格子数目。
+#### 样例输入1
+```
+3 3
+10 1 52
+20 30 1
+1 2 3
+```
+#### 样例输出1
+```
+3
+```
+#### 样例输入2
+```
+4 3
+1 1 1 1
+1 30 80 2
+1 1 1 100
+```
+#### 样例输出2
+```
+10
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/151.\350\277\236\345\217\267\345\214\272\351\227\264\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/151.\350\277\236\345\217\267\345\214\272\351\227\264\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7e4cdb2efc1c98d57b9958bbc21cb8f16257b125
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/151.\350\277\236\345\217\267\345\214\272\351\227\264\346\225\260/solution.md"
@@ -0,0 +1,73 @@
+# 连号区间数
+
+#### 问题描述
+小明这些天一直在思考这样一个奇怪而有趣的问题：  
+在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是：  
+如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。  
+当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助。
+
+#### 输入格式
+第一行是一个正整数N (1 <= N <= 50000), 表示全排列的规模。  
+第二行是N个不同的数字Pi(1 <= Pi <= N)， 表示这N个数字的某一全排列。  
+
+#### 输出格式
+输出一个整数，表示不同连号区间的数目。
+
+#### 样例输入1
+```
+4
+3 2 4 1
+```
+#### 样例输出1
+```
+7
+```
+#### 样例输入2
+```
+5
+3 4 2 5 1
+```
+#### 样例输出2
+```
+9
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/152.\345\271\264\345\217\267\345\255\227\347\254\246/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/152.\345\271\264\345\217\267\345\255\227\347\254\246/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ef967f9d7dec625885f66e8b75fc2dd8c445f5cf
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/152.\345\271\264\345\217\267\345\255\227\347\254\246/solution.md"
@@ -0,0 +1,45 @@
+# 年号字符
+
+小明用字母 A 对应数字 1，B 对应 2，以此类推，用 Z 对应 26。对于 27 以上的数字，小明用两位或长位的字符串来对应，例如 AA 对应 27，AB 对 应 28，AZ 对应 52，LQ 对应 329。  
+请问 2019 对应的字符串是什么？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/153.\346\225\264\346\225\260\346\213\274\346\216\245/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/153.\346\225\264\346\225\260\346\213\274\346\216\245/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c416d2dc1808860508d2619cc3e751c989f1e775
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/153.\346\225\264\346\225\260\346\213\274\346\216\245/solution.md"
@@ -0,0 +1,75 @@
+# 整数拼接
+
+#### 问题描述
+给定义个长度为 n 的数组 $A_1, A_2 , ··· , A_n$。
+
+你可以从中选出两个数 $A_i 和 A_j$ (i 不等于 j)，然后将 $A_i 和 A_j$ 一前一后拼成一个新的整数。
+
+例如 12 和 345 可以拼成 12345 或 34512。
+
+注意交换 $A_i$ 和 $A_j$ 的顺序总是被视为 2 种拼法，即便是 $A_i$ = $A_j$ 时。
+
+请你计算有多少种拼法满足拼出的整数是 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$
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/154.\345\260\217\346\234\213\345\217\213\345\264\207\346\213\234\345\234\210/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/154.\345\260\217\346\234\213\345\217\213\345\264\207\346\213\234\345\234\210/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7ad83d410f82785e01efb7269b9ba9952c16bd58
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/154.\345\260\217\346\234\213\345\217\213\345\264\207\346\213\234\345\234\210/solution.md"
@@ -0,0 +1,82 @@
+# 小朋友崇拜圈
+
+#### 问题描述：
+
+班里 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
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/155.\344\271\246\345\217\267\351\252\214\350\257\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/155.\344\271\246\345\217\267\351\252\214\350\257\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cc31d63e43d884f45253f0342707800690d2d61a
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/155.\344\271\246\345\217\267\351\252\214\350\257\201/solution.md"
@@ -0,0 +1,50 @@
+# 书号验证
+
+2004年起，国际ISBN中心出版了《13位国际标准书号指南》。  
+原有10位书号前加978作为商品分类标识；校验规则也改变。  
+校验位的加权算法与10位ISBN的算法不同，具体算法是：
+1. 用1分别乘ISBN的前12位中的奇数位（从左边开始数起），用3乘以偶数位，乘积之和以10为模，
+2. 10与模值的差值再对10取模（即取个位的数字）即可得到校验位的值，其值范围应该为0~9。
+
+下面的程序实现了该算法，请仔细阅读源码，填写缺失的部分。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/157.\345\244\226\345\215\226\345\272\227\344\274\230\345\205\210\347\272\247/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/157.\345\244\226\345\215\226\345\272\227\344\274\230\345\205\210\347\272\247/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bf792db28a45a39493e6928e9fef225409334a16
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/157.\345\244\226\345\215\226\345\272\227\344\274\230\345\205\210\347\272\247/solution.md"
@@ -0,0 +1,73 @@
+# 外卖店优先级
+
+#### 问题描述
+“饱了么”外卖系统中维护着 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。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/159.\346\216\222\345\272\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/159.\346\216\222\345\272\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..826d5f357f09d60373a4368ce157e5425a974e59
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/159.\346\216\222\345\272\217/solution.md"
@@ -0,0 +1,55 @@
+# 排序
+
+#### 问题描述
+编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。  
+输入格式：输入只有一行，即三个整数，中间用空格隔开。  
+输出格式：输出只有一行，即排序后的结果。  
+### 输入输出样例
+#### 样例输入
+```
+9 2 30
+```
+#### 样例输出
+```
+30 9 2
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/16.\345\276\252\347\216\257\350\212\202\351\225\277\345\272\246/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/16.\345\276\252\347\216\257\350\212\202\351\225\277\345\272\246/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..efe639c7f2b1d645010379ea750fd38597b2ba4d
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/16.\345\276\252\347\216\257\350\212\202\351\225\277\345\272\246/solution.md"
@@ -0,0 +1,45 @@
+# 循环节长度
+
+两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。   
+比如，11/13=6=>0.846153846153….. 其循环节为[846153] 共有6位。   
+下面的方法，可以求出循环节的长度。  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/160.\345\257\222\345\201\207\344\275\234\344\270\232/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/160.\345\257\222\345\201\207\344\275\234\344\270\232/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..02bbaafed82ab8f5c3d9e8bf1d1d144bbc47d057
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/160.\345\257\222\345\201\207\344\275\234\344\270\232/solution.md"
@@ -0,0 +1,68 @@
+# 寒假作业
+
+现在小学的数学题目也不是那么好玩的。  
+看看这个寒假作业：  
+```
+□ + □ = □
+□ - □ = □
+□ × □ = □
+□ ÷ □ = □
+```
+每个方块代表1~13中的某一个数字，但不能重复。比如：
+```
+6 + 7 = 13
+9 - 8 = 1
+3 * 4 = 12
+10 / 2 = 5
+```
+以及：
+```
+7 + 6 = 13
+9 - 8 = 1
+3 * 4 = 12
+10 / 2 = 5
+```
+就算两种解法。（加法，乘法交换律后算不同的方案）
+
+你一共找到了多少种方案？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/161.\351\255\224\346\226\271\346\250\241\346\213\237/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/161.\351\255\224\346\226\271\346\250\241\346\213\237/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ebbd1b5027c4dc45662173d36ac3699cec2f8738
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/161.\351\255\224\346\226\271\346\250\241\346\213\237/solution.md"
@@ -0,0 +1,95 @@
+# 魔方模拟
+
+魔方可以对它的6个面自由旋转。
+我们来操作一个2阶魔方（如图所示）：
+
+为了描述方便，我们为它建立了坐标系。
+
+各个面的初始状态如下：
+```
+x轴正向：绿
+x轴反向：蓝
+y轴正向：红
+y轴反向：橙
+z轴正向：白
+z轴反向：黄
+```
+假设我们规定，只能对该魔方进行3种操作。分别标记为：
+```
+x 表示在x轴正向做顺时针旋转
+y 表示在y轴正向做顺时针旋转
+z 表示在z轴正向做顺时针旋转
+```
+xyz 则表示顺序执行x,y,z 3个操作  
+![](https://img-blog.csdn.net/20170113214548029) 
+
+![](https://img-blog.csdn.net/20170113214552070)
+
+![](https://img-blog.csdn.net/20170113214558404)
+
+![](https://img-blog.csdn.net/20170113214602149)
+
+题目的要求是：
+从标准输入获得一个串，表示操作序列。  
+程序输出：距离我们最近的那个小方块的3个面的颜色。  
+顺序是：x面，y面，z面。  
+
+例如：在初始状态，应该输出：
+绿红白
+
+初始状态下，如果用户输入：
+```
+x
+```
+则应该输出：
+```
+绿白橙
+```
+初始状态下，如果用户输入：
+```
+zyx
+```
+则应该输出：
+```
+红白绿
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/164.\347\275\221\345\217\213\345\271\264\351\276\204/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/164.\347\275\221\345\217\213\345\271\264\351\276\204/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cb6785050664bba2631c72d3f192de81a67710df
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/164.\347\275\221\345\217\213\345\271\264\351\276\204/solution.md"
@@ -0,0 +1,45 @@
+# 网友年龄
+
+某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄”  
+请你计算：网友的年龄一共有多少种可能情况？  
+提示：30岁就是其中一种可能哦.  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/165.\345\223\252\345\244\251\350\277\224\345\233\236/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/165.\345\223\252\345\244\251\350\277\224\345\233\236/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fc56e6b7d30a0358d42c04c773372c8accc5af79
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/165.\345\223\252\345\244\251\350\277\224\345\233\236/solution.md"
@@ -0,0 +1,48 @@
+# 哪天返回
+
+小明被不明势力劫持，后莫名其妙被扔到x星站再无问津。  
+小明得知每天都有飞船飞往地球，但需要 108 元的船票，而他却身无分文，他决定在 x 星战打工。  
+好心的老板答应包食宿，第 1 天给他 1 元钱，并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。
+请计算一下，小明在第几天就能凑够 108 元，返回地球。
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/166.\345\245\207\346\200\252\347\232\204\345\210\206\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/166.\345\245\207\346\200\252\347\232\204\345\210\206\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..669bd43d59e9abbb0a5be6c971118bf742f3eeda
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/166.\345\245\207\346\200\252\347\232\204\345\210\206\345\274\217/solution.md"
@@ -0,0 +1,55 @@
+# 奇怪的分式
+
+上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：  
+1/4 乘以 8/5  
+小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 
+
+![](https://images2015.cnblogs.com/blog/1139769/201704/1139769-20170406155423800-1872161918.png)
+
+
+老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！  
+对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？  
+请写出所有不同算式的个数（包括题中举例的）。  
+显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。  
+但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/167.\345\277\253\351\200\237\346\216\222\345\272\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/167.\345\277\253\351\200\237\346\216\222\345\272\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..29f1f93649943c9a9b04ba64cca9563b15d29f00
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/167.\345\277\253\351\200\237\346\216\222\345\272\217/solution.md"
@@ -0,0 +1,57 @@
+# 快速排序
+
+#### 问题描述
+用递归来实现快速排序（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
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/168.\347\247\273\345\212\250\350\267\235\347\246\273/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/168.\347\247\273\345\212\250\350\267\235\347\246\273/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cbf2caf631577c5754351335917cc2ec39a8f94b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/168.\347\247\273\345\212\250\350\267\235\347\246\273/solution.md"
@@ -0,0 +1,74 @@
+# 移动距离
+
+X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3...  
+当排满一行时，从下一行相邻的楼往反方向排号。  
+比如：当小区排号宽度为6时，开始情形如下：  
+```
+1  2  3  4  5  6
+12 11 10 9  8  7
+13 14 15 .....
+```
+我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）  
+
+输入为3个整数w m n，空格分开，都在1到10000范围内  
+w为排号宽度，m,n为待计算的楼号。  
+要求输出一个整数，表示m n 两楼间最短移动距离。  
+
+例如：
+#### 用户输入：
+```
+6 8 2
+```
+则，程序应该输出：
+```
+4
+```
+再例如：
+#### 用户输入：
+```
+4 7 20
+```
+则，程序应该输出：
+```
+5
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/169.\345\245\207\346\200\252\347\232\204\346\257\224\350\265\233/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/169.\345\245\207\346\200\252\347\232\204\346\257\224\350\265\233/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..387a0484ad44ca930fdd1156af078a9ccbfef586
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/169.\345\245\207\346\200\252\347\232\204\346\257\224\350\265\233/solution.md"
@@ -0,0 +1,50 @@
+# 奇怪的比赛
+
+某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：  
+每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。  
+每位选手都有一个起步的分数为10分。  
+某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？  
+如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和0的串来表示。例如：0010110011 就是可能的情况。  
+
+你的任务是算出所有可能情况。每个答案占一行。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/17.\346\227\245\345\277\227\347\273\237\350\256\241/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/17.\346\227\245\345\277\227\347\273\237\350\256\241/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0b7895c1b9be17fda1cac4ab5db638145b63c5e5
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/17.\346\227\245\345\277\227\347\273\237\350\256\241/solution.md"
@@ -0,0 +1,89 @@
+# 日志统计
+
+#### 题目描述
+小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 N 行。  
+
+其中每一行的格式是：  
+ts id  
+表示在 ts 时刻编号 id 的帖子收到一个”赞”。
+
+现在小明想统计有哪些帖子曾经是”热帖”。  
+
+如果一个帖子曾在任意一个长度为 D 的时间段内收到不少于 K 个赞，小明就认为这个帖子曾是”热帖”。
+
+具体来说，如果存在某个时刻 T 满足该帖在 [T,T+D) 这段时间内(注意是左闭右开区间)收到不少于 K 个赞，该帖就曾是”热帖”。
+
+给定日志，请你帮助小明统计出所有曾是”热帖”的帖子编号。
+
+#### 输入格式
+第一行包含三个整数 N,D,K。
+
+以下 N 行每行一条日志，包含两个整数 ts 和 id。
+
+#### 输出格式
+按从小到大的顺序输出热帖 id。
+
+每个 id 占一行。
+
+#### 数据范围
+```
+1≤K≤N≤10E5,
+0≤ts,id≤10E5,
+1≤D≤10000
+```
+#### 输入样例：
+```
+7 10 2
+0 1
+0 10
+10 10
+10 1
+9 1
+100 3
+100 3
+```
+#### 输出样例：
+```
+1
+3
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/170.\345\271\270\350\277\220\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/170.\345\271\270\350\277\220\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6e35f48c727f9566ec73cc7573c964b9b17d9997
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/170.\345\271\270\350\277\220\346\225\260/solution.md"
@@ -0,0 +1,77 @@
+# 幸运数
+
+#### 问题描述
+幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。  
+首先从1开始写出自然数1,2,3,4,5,6,…  
+1 就是第一个幸运数。  
+我们从2这个数开始。把所有序号能被2整除的项删除，变为：  
+1 _ 3 _ 5 _ 7 _ 9 …  
+把它们缩紧，重新记序，为：  
+1 3 5 7 9 … 。  
+这时，3为第2个幸运数，然后把所有能被3整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被3整除!! 删除的应该是5，11, 17, …  
+此时7为第3个幸运数，然后再删去序号位置能被7整除的(19,39,…)  
+最后剩下的序列类似：  
+```
+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 20
+```
+#### 样例输出1
+```
+5
+```
+#### 样例输入2
+```
+30 69
+```
+#### 样例输出2
+```
+8
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/171.\345\212\240\346\263\225\345\217\230\344\271\230\346\263\225/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/171.\345\212\240\346\263\225\345\217\230\344\271\230\346\263\225/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ae050da651ed4300a163e152ac4bcb5d0f7d93a0
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/171.\345\212\240\346\263\225\345\217\230\344\271\230\346\263\225/solution.md"
@@ -0,0 +1,53 @@
+# 加法变乘法
+
+#### 题目描述：
+我们都知道：1+2+3+ … + 49 = 1225
+
+现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
+
+比如：
+
+1+2+3+…+1011+12+…+2728+29+…+49 = 2015 就是符合要求的答案。
+
+请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/172.\344\277\256\346\224\271\346\225\260\347\273\204/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/172.\344\277\256\346\224\271\346\225\260\347\273\204/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..37073156ed8d1c45b4b8be5332a688fdf4963f9a
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/172.\344\277\256\346\224\271\346\225\260\347\273\204/solution.md"
@@ -0,0 +1,67 @@
+# 修改数组
+
+#### 问题描述
+给定一个长度为 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
+```
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/173.\345\211\215\347\274\200\345\210\244\346\226\255/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/173.\345\211\215\347\274\200\345\210\244\346\226\255/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1ab2e0e025e8c99abf85d4849fa6048ba8c11a01
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/173.\345\211\215\347\274\200\345\210\244\346\226\255/solution.md"
@@ -0,0 +1,44 @@
+# 前缀判断
+
+如下的代码判断 needle_start指向的串是否为haystack_start指向的串的前缀，如不是，则返回NULL。  
+比如："abcd1234" 就包含了 "abc" 为前缀
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/174.\347\272\252\345\277\265\346\227\245/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/174.\347\272\252\345\277\265\346\227\245/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..efc7c73cb3932d3988946acfd973128ebbd31dd9
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/174.\347\272\252\345\277\265\346\227\245/solution.md"
@@ -0,0 +1,43 @@
+# 纪念日
+
+请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包含多少分钟？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/176.\346\262\271\346\274\206\351\235\242\347\247\257/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/176.\346\262\271\346\274\206\351\235\242\347\247\257/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a8ba81462645993cfa17983417e2599ccabab63e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/176.\346\262\271\346\274\206\351\235\242\347\247\257/solution.md"
@@ -0,0 +1,83 @@
+# 油漆面积
+
+#### 问题描述
+X星球的一批考古机器人正在一片废墟上考古。  
+该区域的地面坚硬如石、平整如镜。  
+管理人员为方便，建立了标准的直角坐标系。  
+每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。  
+经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。  
+矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。  
+为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。  
+小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。  
+其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。  
+注意，各个矩形间可能重叠。  
+本题的输入为若干矩形，要求输出其覆盖的总面积。  
+　　
+#### 输入格式
+第一行，一个整数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
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/177.\345\257\206\347\240\201\345\217\221\347\224\237\345\231\250/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/177.\345\257\206\347\240\201\345\217\221\347\224\237\345\231\250/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2804b89d5db27904312f8c22b31d070eb43bc91b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/177.\345\257\206\347\240\201\345\217\221\347\224\237\345\231\250/solution.md"
@@ -0,0 +1,83 @@
+# 密码发生器
+
+在对银行账户等重要权限设置密码的时候，我们常常遇到这样的烦恼：如果为了好记用生日吧，容易被破解不安全；如果设置不好记的密码，又担心自己也会忘记；如果写在纸上，担心纸张被别人发现或弄丢了...
+
+这个程序的任务就是把一串拼音字母转换为6位数字（密码）。我们可以使用任何好记的拼音串(比如名字，喜明，就写：wangximing)作为输入，程序输出6位数字。
+
+变换的过程如下：
+
+第一步. 把字符串6个一组折叠起来，比如wangximing则变为：
+wangxi
+ming 
+
+第二步. 把所有垂直在同一个位置的字符的ascii码值相加，得出6个数字，如上面的例子，则得出：
+228 202 220 206 120 105
+
+第三步. 再把每个数字“缩位”处理：就是把每个位的数字相加，得出的数字如果不是一位数字，就再缩位，到变成一位数字为止。例如: 228 => 2+2+8=12 => 1+2=3
+
+上面的数字缩位后变为：344836, 这就是程序最终的输出结果！
+
+要求程序从标准输入接收数据，在标准输出上输出结果。
+
+#### 输入格式为：
+第一行是一个整数n（<100），表示下边有多少输入行，接下来是n行字符串，就是等待变换的符串。
+#### 输出格式为：
+n行变换后的6位密码。
+
+#### 输入：
+```
+5
+zhangfeng
+wangximing
+jiujingfazi
+woaibeijingtiananmen
+haohaoxuexi
+```
+#### 输出：
+```
+772243
+344836
+297332
+716652
+875843
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/178.RSA \350\247\243\345\257\206/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/178.RSA \350\247\243\345\257\206/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..70c080a28497ac72bca90dfe34f6fa26dccef467
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/178.RSA \350\247\243\345\257\206/solution.md"	
@@ -0,0 +1,53 @@
+# RSA 解密
+
+RSA是一种经典的加密算法。它的基本加密过程如下。
+
+首先生成两个质数p,q, 令$n = p \cdot q$,设d与$(p-1) \cdot (q-1)$互质，则可以找到e,使得$d \cdot e$除以$(p-1) \cdot (q-1)$的余数为1  
+n,d,e组成了私钥，n,d构成了公钥。  
+当使用公钥加密一个整数X时(X<=n-1)，计算$C = X^d$ mod n，则C是加密后的密文。  
+当收到密文C时，可以使用私钥解开，计算公式为：$X = C^e$ mod n。  
+例如：当p = 5, q = 11, n = 55, e = 27。  
+若加密数字24,得$24^3$ % 55 = 19。  
+解密数字19，得$19^{27}$ % 55 = 24。  
+现在你知道公钥中n = 1001733993063167141,d = 212353,同时，你截获了别人发送的密文C = 20190324,请问，原文是多少？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/179.\346\225\264\351\231\244\345\272\217\345\210\227/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/179.\346\225\264\351\231\244\345\272\217\345\210\227/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6f79e8d534e7d1bdf38e0fe5d90fe566ff3fbe90
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/179.\346\225\264\351\231\244\345\272\217\345\210\227/solution.md"
@@ -0,0 +1,60 @@
+# 整除序列
+
+有一个序列，序列的第一个数是n，后面的每个数是前一个数整除2，请输出这个序列中值为正数的项。
+#### 输入格式
+输入一行包含一个整数n。
+#### 输出格式
+输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。
+#### 样例输入
+```
+20
+```
+#### 样例输出
+```
+20 10 5 2 1
+```
+#### 评测用例规模与约定
+```
+对于80% 的评测用例，1 < n <= 10^9。  
+对于所有评测用例，1 < n <=10^18。  
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/18.\350\267\263\350\232\261\350\234\242/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/18.\350\267\263\350\232\261\350\234\242/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..25778b20fe578f28ded1f687880c1803e03ad2d1
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/18.\350\267\263\350\232\261\350\234\242/solution.md"
@@ -0,0 +1,53 @@
+# 跳蚱蜢
+
+有 9 只盘子，排成 1 个圆圈。
+
+其中 8 只盘子内装着 8 只蚱蜢，有一个是空盘，我们把这些蚱蜢顺时针编号为 1 ~ 8
+
+每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
+
+请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
+
+并且保持空盘的位置不变（也就是 1-8 换位，2-7 换位,…），至少要经过多少次跳跃？
+
+![](https://img-blog.csdnimg.cn/20200530104930106.png)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/180.\346\255\246\345\212\237\347\247\230\347\261\215/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/180.\346\255\246\345\212\237\347\247\230\347\261\215/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fdaeffed8b33de28f388de8029912594b3b28035
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/180.\346\255\246\345\212\237\347\247\230\347\261\215/solution.md"
@@ -0,0 +1,44 @@
+# 武功秘籍
+
+小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。  
+小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/181.\344\273\230\350\264\246\351\227\256\351\242\230/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/181.\344\273\230\350\264\246\351\227\256\351\242\230/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c6bf641e5da9d318fe3223e56805635223d8dc7b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/181.\344\273\230\350\264\246\351\227\256\351\242\230/solution.md"
@@ -0,0 +1,97 @@
+# 付账问题
+
+#### 题目描述
+几个人一起出去吃饭是常有的事。但在结帐的时候，常常会出现一些争执。
+
+现在有 n 个人出去吃饭，他们总共消费了 S 元。其中第 i 个人带了 ai 元。幸运的是，所有人带的钱的总数是足够付账的，但现在问题来了：每个人分别要出多少钱呢？
+
+为了公平起见，我们希望在总付钱量恰好为 S 的前提下，最后每个人付的钱的标准差最小。这里我们约定，每个人支付的钱数可以是任意非负实数，即可以不是1分钱的整数倍。你需要输出最小的标准差是多少。
+
+标准差的介绍：标准差是多个数与它们平均数差值的平方平均数，一般用于刻画这些数之间的“偏差有多大”。形式化地说，设第 i 个人付的钱为 bi 元，那么标准差为 :
+ ![参见p1.png](https://img-blog.csdnimg.cn/20201015164915888.png#pic_center)
+
+
+#### 输入格式
+从标准输入读入数据。
+
+第一行包含两个整数 n、S；  
+第二行包含 n 个非负整数 a1, …, an。
+
+#### 输出格式
+输出到标准输出。  
+
+输出最小的标准差，四舍五入保留 4 位小数。  
+保证正确答案在加上或减去 10^−9 后不会导致四舍五入的结果发生变化。  
+
+#### 样例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
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/182.\345\217\244\345\240\241\347\256\227\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/182.\345\217\244\345\240\241\347\256\227\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5e7e35e37b9def675153e4658f1c6b3a5f1d5a3f
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/182.\345\217\244\345\240\241\347\256\227\345\274\217/solution.md"
@@ -0,0 +1,50 @@
+# 古堡算式
+
+福尔摩斯到某古堡探险，看到门上写着一个奇怪的算式：  
+ABCDE * ? = EDCBA  
+他对华生说：“ABCDE应该代表不同的数字，问号也代表某个数字！”  
+华生：“我猜也是！”  
+于是，两人沉默了好久，还是没有算出合适的结果来。  
+请你利用计算机的优势，找到破解的答案。  
+把 ABCDE 所代表的数字写出来。  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/183.\345\245\226\345\210\270\346\225\260\347\233\256/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/183.\345\245\226\345\210\270\346\225\260\347\233\256/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..786e1bbf3667e1056ef155ec44f4502708b1df3f
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/183.\345\245\226\345\210\270\346\225\260\347\233\256/solution.md"
@@ -0,0 +1,45 @@
+# 奖券数目
+
+有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。  
+虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/184.\345\245\207\345\246\231\347\232\204\346\225\260\345\255\227/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/184.\345\245\207\345\246\231\347\232\204\346\225\260\345\255\227/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d36079b5326a4605733a52df2309642434ddbd21
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/184.\345\245\207\345\246\231\347\232\204\346\225\260\345\255\227/solution.md"
@@ -0,0 +1,44 @@
+# 奇妙的数字
+
+小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。  
+你能猜出这个数字是多少吗？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/185.\345\217\226\347\220\203\345\215\232\345\274\210/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/185.\345\217\226\347\220\203\345\215\232\345\274\210/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d6f9979109421afd950ccba6af7149336e262713
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/185.\345\217\226\347\220\203\345\215\232\345\274\210/solution.md"
@@ -0,0 +1,86 @@
+# 取球博弈
+
+#### 问题描述
+两个人玩取球的游戏。  
+一共有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 2 3
+1 2 3 4 5
+```
+#### 输出例子 1
+```
++ 0 + 0 -
+```
+#### 输入例子 2
+```
+1 4 5
+10 11 12 13 15
+```
+#### 输出例子 2
+```
+0 - 0 + +
+```
+#### 输入例子 3
+```
+2 3 5
+7 8 9 10 11
+```
+#### 输出例子 3
+```
++ 0 0 0 0
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/186.\347\250\215\345\260\217\345\210\206\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/186.\347\250\215\345\260\217\345\210\206\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d27a85348bc503b8616f0f121ef798f479617594
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/186.\347\250\215\345\260\217\345\210\206\346\225\260/solution.md"
@@ -0,0 +1,52 @@
+# 稍小分数
+
+回到小学
+
+真分数：分子小于分母的分数
+
+既约分数：分子分母互质，也就是说最大公约数是1
+
+x星球数学城的入口验证方式是：
+
+屏幕上显示一个真分数，需要你快速地找到一个比它小的既约分数，要求这个分数越大越好。  
+同时限定你的这个分数的分母不能超过100。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/189.\351\251\254\350\231\216\347\232\204\347\256\227\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/189.\351\251\254\350\231\216\347\232\204\347\256\227\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2bdd12792580a8e612dbefb12275b15fa800b13d
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/189.\351\251\254\350\231\216\347\232\204\347\256\227\345\274\217/solution.md"
@@ -0,0 +1,62 @@
+# 马虎的算式
+
+小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。
+
+有一次，老师出的题目是：36 x 495 = ?
+
+他却给抄成了：396 x 45 = ?
+
+但结果却很戏剧性，他的答案竟然是对的！！
+
+因为 36 * 495 = 396 * 45 = 17820
+
+类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54
+
+假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）
+
+能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？
+
+请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
+
+满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/19.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/19.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c89cd530466bb0238efcfee28e9e252f51449d9e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/19.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.md"
@@ -0,0 +1,81 @@
+# 人物相关性分析
+
+小明正在分析一本小说中的人物相关性。
+
+他想知道在小说中 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 同时出现的次数。
+
+#### 数据范围
+```
+1≤K≤1000000
+```
+#### 输入样例：
+```
+20
+This is a story about Alice and Bob. Alice wants to send a private message to Bob.
+```
+输出样例：
+```
+2
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/2.\346\230\237\347\263\273\347\202\270\345\274\271/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/2.\346\230\237\347\263\273\347\202\270\345\274\271/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0edc91efff82fa26af356c278d4becdc64444d81
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/2.\346\230\237\347\263\273\347\202\270\345\274\271/solution.md"
@@ -0,0 +1,47 @@
+# 星系炸弹
+
+在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。  
+每个炸弹都可以设定多少天之后爆炸。  
+比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。  
+有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/20.\347\245\236\345\245\207\347\256\227\345\274\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/20.\347\245\236\345\245\207\347\256\227\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..98454f14ee11b190007e38da18b9327a55da9299
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/20.\347\245\236\345\245\207\347\256\227\345\274\217/solution.md"
@@ -0,0 +1,52 @@
+# 神奇算式
+
+由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。
+比如： 
+```
+210 x 6 = 1260 
+8 x 473 = 3784
+27 x 81 = 2187 
+```
+都符合要求。  
+如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/21.\350\247\243\347\240\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/21.\350\247\243\347\240\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..396931337dc76337175d1916a3ed8d086cfd2b38
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/21.\350\247\243\347\240\201/solution.md"
@@ -0,0 +1,70 @@
+# 解码
+
+#### 问题描述
+
+小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
+
+例如，连续的 5 个 a，即 aaaaa，小明可以简写成 a5（也可能简写成 a4a、aa3a 等）。对于这个例子：HHHellllloo，小明可以简写成 H3el5o2。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
+现在给出简写后的字符串，请帮助小明还原成原来的串。
+
+#### 输入格式
+
+输入一行包含一个字符串。
+
+#### 输出格式
+
+输出一个字符串，表示还原后的串。
+
+#### 样例输入
+```
+H3el5o2
+```
+#### 样例输出
+```
+HHHellllloo
+```
+#### 评测用例规模与约定
+
+对于所有评测用例，字符串由大小写英文字母和数字组成，长度不超过100。
+
+请注意原来的串长度可能超过 100。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/22.\346\230\237\346\234\237\344\270\200/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/22.\346\230\237\346\234\237\344\270\200/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4500ff48cf1f90b231138ca379247f05f2bc7dfe
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/22.\346\230\237\346\234\237\344\270\200/solution.md"
@@ -0,0 +1,43 @@
+# 星期一
+
+整个20世纪（1901年1月1日至2000年12月31日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/25.\347\275\221\347\273\234\345\210\206\346\236\220/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/25.\347\275\221\347\273\234\345\210\206\346\236\220/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..80a00d90d921c40508a968b2e4cfe4c47b842061
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/25.\347\275\221\347\273\234\345\210\206\346\236\220/solution.md"
@@ -0,0 +1,83 @@
+# 网络分析
+
+#### 问题描述
+小明正在做一个网络实验。
+他设置了 n 台电脑，称为节点，用于收发和存储数据。初始时，所有节点都是独立的，不存在任何连接。  
+小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。  
+小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。
+一条信息只存储一次。  
+给出小明连接和测试的过程，请计算出每个节点存储信息的大小。  
+
+#### 输入格式
+输入的第一行包含两个整数 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
+2 1 10
+2 3 5
+1 4 1
+2 2 2
+1 1 2
+1 2 4
+2 2 1
+```
+#### 样例输出
+```
+13 13 5 3
+```
+#### 评测用例规模与约定
+```
+对于 30% 的评测用例，1 ≤ n ≤ 20，1 ≤ m ≤ 100。
+对于 50% 的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 1000。
+对于 70% 的评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 10000。
+对于所有评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ t ≤ 100。
+```
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/26.\346\234\211\347\220\206\346\225\260\347\261\273/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/26.\346\234\211\347\220\206\346\225\260\347\261\273/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bf28f4d51da697c73cfd9be661673d22d3de0419
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/26.\346\234\211\347\220\206\346\225\260\347\261\273/solution.md"
@@ -0,0 +1,46 @@
+# 有理数类
+
+有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。  
+但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。  
+这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。  
+为了简明，它只提供了加法和乘法运算。  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/27.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/27.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b61a188d43bd8327b69c8d88991d2f11ef050005
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/27.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.md"
@@ -0,0 +1,88 @@
+# 组合数问题
+
+#### 问题描述
+给 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 个评测用例测试你的程序
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/29.\347\224\237\346\227\245\350\234\241\347\203\233/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/29.\347\224\237\346\227\245\350\234\241\347\203\233/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b5413409599546cea75a5ab611975a98c0bc5ede
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/29.\347\224\237\346\227\245\350\234\241\347\203\233/solution.md"
@@ -0,0 +1,44 @@
+# 生日蜡烛
+
+某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一吹熄了236根蜡烛。  
+请问，他从多少岁开始过生日party的？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/31.\345\220\210\345\271\266\346\243\200\346\265\213/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/31.\345\220\210\345\271\266\346\243\200\346\265\213/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ce5eee8533fd19b16e7fe40e4d12958e21eca106
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/31.\345\220\210\345\271\266\346\243\200\346\265\213/solution.md"
@@ -0,0 +1,46 @@
+# 合并检测
+
+新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准 备给大量民众进病毒核酸检测。  
+然而，用于检测的试剂盒紧缺。为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k 个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k 个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明 至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看， 如果检测前 k−1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中 不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用 了 k + 1 个试剂盒完成了 k 个人的检测。  
+A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能最节省试剂盒？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/32.\345\233\236\346\226\207\346\227\245\346\234\237/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/32.\345\233\236\346\226\207\346\227\245\346\234\237/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b5ae1e6b957d82dbdcfb07a60d87670ab3510cee
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/32.\345\233\236\346\226\207\346\227\245\346\234\237/solution.md"
@@ -0,0 +1,65 @@
+# 回文日期
+
+#### 问题描述
+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
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/33.\344\271\235\346\225\260\345\210\206\344\270\211\347\273\204/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/33.\344\271\235\346\225\260\345\210\206\344\270\211\347\273\204/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bc3c0240c733663d5f7752ccebaa73d0c92aa756
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/33.\344\271\235\346\225\260\345\210\206\344\270\211\347\273\204/solution.md"
@@ -0,0 +1,48 @@
+# 九数分三组
+
+1~9的数字可以组成3个3位数，设为：A,B,C, 现在要求满足如下关系：
+```
+B = 2 * A  
+C = 3 * A  
+```
+请你写出A的所有可能答案，数字间用空格分开，数字按升序排列。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/34.\346\211\221\345\205\213\345\272\217\345\210\227/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/34.\346\211\221\345\205\213\345\272\217\345\210\227/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..42456d01aaa3ac9406c6ec6dc3ecf47f24bcfb19
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/34.\346\211\221\345\205\213\345\272\217\345\210\227/solution.md"
@@ -0,0 +1,50 @@
+# 扑克序列
+
+A A 2 2 3 3 4 4， 一共4对扑克牌。请你把它们排成一行。  
+要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。
+
+请填写出所有符合要求的排列中，字典序最小的那个。
+
+例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/37.\347\263\226\346\236\234/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/37.\347\263\226\346\236\234/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..0303c90f86ce0bb388a884c1df59f04c23ca14bc
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/37.\347\263\226\346\236\234/solution.md"
@@ -0,0 +1,67 @@
+# 糖果
+
+糖果店的老板一共有M种口味的糖果出售。为了方便描述，我们将M种口味编号1~M。  
+小明希望能品尝到所有口味的糖果。遗憾的是老板并不单独出售糖果，而是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
+1 2 3
+1 1 3
+2 3 5
+5 4 2
+5 1 2
+```
+#### 样例输出
+```
+2
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/38.\345\260\217\346\234\213\345\217\213\346\216\222\351\230\237/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/38.\345\260\217\346\234\213\345\217\213\346\216\222\351\230\237/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bcc854b4d8761838bfe946466baee76da7f9e7ae
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/38.\345\260\217\346\234\213\345\217\213\346\216\222\351\230\237/solution.md"
@@ -0,0 +1,81 @@
+# 小朋友排队
+
+#### 题目描述
+n 个小朋友站成一排。
+
+现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。
+
+每个小朋友都有一个不高兴的程度。
+
+开始的时候，所有小朋友的不高兴程度都是 0。
+
+如果某个小朋友第一次被要求交换，则他的不高兴程度增加 1，如果第二次要求他交换，则他的不高兴程度增加 2（即不高兴程度为 3），依次类推。当要求某个小朋友第 k 次交换时，他的不高兴程度增加 k。
+
+请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。
+
+如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。
+
+#### 输入格式
+输入的第一行包含一个整数 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
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/39.\347\201\265\350\203\275\344\274\240\350\276\223/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/39.\347\201\265\350\203\275\344\274\240\350\276\223/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..95770c6dae87dba0aa47c61080e8b0dcac8b6458
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/39.\347\201\265\350\203\275\344\274\240\350\276\223/solution.md"
@@ -0,0 +1,95 @@
+# 灵能传输
+
+#### 题目背景
+在游戏《星际争霸 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
+5 -2 3
+4
+0 0 0 0
+3
+1 2 3
+```
+#### 样例输出
+```
+3
+0
+3
+```
+#### 样例说明
+```
+对于第一组询问：
+对 2 号高阶圣堂武士进行传输操作后 a 1 = 3，a 2 = 2，a 3 = 1。答案为 3。
+对于第二组询问：
+这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。
+```
+#### 样例输入
+```
+3
+4
+-1 -2 -3 7
+4
+2 3 4 -8
+5
+-1 -1 6 -1 -1
+```
+#### 样例输出
+```
+5
+7
+4
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/42.\346\214\257\345\205\264\344\270\255\345\215\216/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/42.\346\214\257\345\205\264\344\270\255\345\215\216/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..32289c2f6c065acb1daa021b11fabafe4dc831c7
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/42.\346\214\257\345\205\264\344\270\255\345\215\216/solution.md"
@@ -0,0 +1,57 @@
+# 振兴中华
+
+小明参加了学校的趣味运动会，其中的一个项目是：跳格子。  
+
+地上画着一些格子，每个格子里写一个字，如下所示：
+```
+从我做起振
+我做起振兴
+做起振兴中
+起振兴中华
+```
+![](https://img-blog.csdn.net/20180327194316347)  
+比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。
+
+要求跳过的路线刚好构成“从我做起振兴中华”这句话。
+
+请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/43.\346\240\274\345\255\220\344\270\255\350\276\223\345\207\272/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/43.\346\240\274\345\255\220\344\270\255\350\276\223\345\207\272/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9764191ad86c9444b8ba10f1147c3a23451290b2
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/43.\346\240\274\345\255\220\344\270\255\350\276\223\345\207\272/solution.md"
@@ -0,0 +1,46 @@
+# 格子中输出
+
+StringInGrid函数会在一个指定大小的格子中打印指定的字符串。 要求字符串在水平、垂直两个方向上都居中。 如果字符串太长，就截断。 如果不能恰好居中，可以稍稍偏左或者偏上一点。  
+输出：
+
+![](https://img-blog.csdnimg.cn/20200327144609874.png#pic_center)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/44.\346\234\200\345\244\247\345\205\254\345\205\261\345\255\220\344\270\262/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/44.\346\234\200\345\244\247\345\205\254\345\205\261\345\255\220\344\270\262/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..654e1aca4476b94824e1e10eb6af7711f89bc34d
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/44.\346\234\200\345\244\247\345\205\254\345\205\261\345\255\220\344\270\262/solution.md"
@@ -0,0 +1,52 @@
+# 最大公共子串
+
+最大公共子串长度问题就是：
+
+求两个串的所有子串中能够匹配上的最大长度是多少。
+
+比如：“abcdkkk” 和 “baabcdadabc”，
+
+可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
+
+下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/45.\345\210\206\345\260\217\347\273\204/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/45.\345\210\206\345\260\217\347\273\204/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c6d2f7e29bd6e9f65bb1d1479c33f36552fa4373
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/45.\345\210\206\345\260\217\347\273\204/solution.md"
@@ -0,0 +1,80 @@
+# 分小组
+
+9名运动员参加比赛，需要分3组进行预赛。有哪些分组的方案呢？  
+我们标记运动员为 A,B,C,... I  
+下面的程序列出了所有的分组方法。  
+该程序的正常输出为：
+```
+ABC DEF GHI
+ABC DEG FHI
+ABC DEH FGI
+ABC DEI FGH
+ABC DFG EHI
+ABC DFH EGI
+ABC DFI EGH
+ABC DGH EFI
+ABC DGI EFH
+ABC DHI EFG
+ABC EFG DHI
+ABC EFH DGI
+ABC EFI DGH
+ABC EGH DFI
+ABC EGI DFH
+ABC EHI DFG
+ABC FGH DEI
+ABC FGI DEH
+ABC FHI DEG
+ABC GHI DEF
+ABD CEF GHI
+ABD CEG FHI
+ABD CEH FGI
+ABD CEI FGH
+ABD CFG EHI
+ABD CFH EGI
+ABD CFI EGH
+ABD CGH EFI
+ABD CGI EFH
+ABD CHI EFG
+ABD EFG CHI
+..... (以下省略，总共560行)。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/46.\351\273\204\351\207\221\350\277\236\345\210\206\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/46.\351\273\204\351\207\221\350\277\236\345\210\206\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9590295b5491cce2a883fd3edfc3c93b7270c542
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/46.\351\273\204\351\207\221\350\277\236\345\210\206\346\225\260/solution.md"
@@ -0,0 +1,70 @@
+# 黄金连分数
+
+黄金分割数0.61803… 是个无理数，这个常数十分重要，在许多工程问题中会出现。有时需要把这个数字求得很精确。  
+对于某些精密工程，常数的精度很重要。也许你听说过哈勃太空望远镜，它首次升空后就发现了一处人工加工错误，对那样一个庞然大物，其实只是镜面加工时有比头发丝还细许多倍的一处错误而已，却使它成了“近视眼”!!  
+言归正传，我们如何求得黄金分割数的尽可能精确的值呢？有许多方法。  
+比较简单的一种是用连分数：  
+```
+                                 1
+    黄金数 			= ---------------------
+                                     1
+                   		1 + -----------------
+                                        1
+                         		1 + -------------
+                                           1
+                               		1 + ---------
+                                        	1 + ...
+
+```
+
+这个连分数计算的“层数”越多，它的值越接近黄金分割数。  
+请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。  
+小数点后3位的值为：0.618  
+小数点后4位的值为：0.6180  
+小数点后5位的值为：0.61803  
+小数点后7位的值为：0.6180340  
+(注意尾部的0，不能忽略）  
+你的任务是：写出精确到小数点后100位精度的黄金分割值。  
+注意：尾数的四舍五入！ 尾数是0也要保留！  
+显然答案是一个小数，其小数点后有100位数字  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/47.k\345\200\215\345\214\272\351\227\264/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/47.k\345\200\215\345\214\272\351\227\264/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fb1a4b085daf8d1fb55de00da658878944bbc264
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/47.k\345\200\215\345\214\272\351\227\264/solution.md"
@@ -0,0 +1,64 @@
+# 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
+2
+3
+4
+5
+```
+#### 样例输出
+```
+6
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/48.\345\216\213\347\274\251\345\217\230\346\215\242/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/48.\345\216\213\347\274\251\345\217\230\346\215\242/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9443d12eaccf8d34fba1ab05b009d1d8d70c7679
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/48.\345\216\213\347\274\251\345\217\230\346\215\242/solution.md"
@@ -0,0 +1,81 @@
+# 压缩变换
+
+#### 问题描述
+小明最近在研究压缩算法。  
+他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。  
+然而，要使数值很小是一个挑战。  
+最近，小明需要压缩一些正整数的序列，这些序列的特点是，后面出现的数字很大可能是刚出现过不久的数字。对于这种特殊的序列，小明准备对序列做一个变换来减小数字的值。  
+变换的过程如下：  
+从左到右枚举序列，每枚举到一个数字，如果这个数字没有出现过，刚将数字变换成它的相反数，如果数字出现过，则看它在原序列中最后的一次出现后面（且在当前数前面）出现了几种数字，用这个种类数替换原来的数字。  
+比如，序列(a1, a2, a3, a4, a5)=(1, 2, 2, 1, 2)在变换过程为：  
+a1: 1未出现过，所以a1变为-1；  
+a2: 2未出现过，所以a2变为-2；  
+a3: 2出现过，最后一次为原序列的a2，在a2后、a3前有0种数字，所以a3变为0；  
+a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字，所以a4变为1；  
+a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。  
+现在，给出原序列，请问，按这种变换规则变换后的序列是什么。  
+
+#### 输入
+输入第一行包含一个整数n，表示序列的长度。  
+第二行包含n个正整数，表示输入序列。  
+
+#### 输出
+输出一行，包含n个数，表示变换后的序列。  
+
+#### 输入例子 1
+```
+5
+1 2 2 1 2
+```
+#### 输出例子 1
+```
+-1 -2 0 1 1
+```
+#### 输入例子 2
+```
+12
+```
+#### 输出例子 2
+```
+-1 0 -2 -3 1 1 2 2 0 0 2 2
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/49.\347\272\270\347\211\214\344\270\211\350\247\222\345\275\242/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/49.\347\272\270\347\211\214\344\270\211\350\247\222\345\275\242/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1fb71a0637d5eba75595d189f31db51a563728c8
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/49.\347\272\270\347\211\214\344\270\211\350\247\222\345\275\242/solution.md"
@@ -0,0 +1,54 @@
+# 纸牌三角形
+
+A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。  
+下面就是一种排法
+```
+   A
+  9 6
+ 4   8
+3 7 5 2
+```
+
+这样的排法可能会有很多。
+
+如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/5.\350\233\207\345\275\242\345\241\253\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/5.\350\233\207\345\275\242\345\241\253\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4169c0a2e1657e8a8dc739bf6a8e74e12640429f
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/5.\350\233\207\345\275\242\345\241\253\346\225\260/solution.md"
@@ -0,0 +1,46 @@
+# 蛇形填数
+
+如下图所示，小明用从1 开始的正整数“蛇形”填充无限大的矩阵。  
+![](https://img-blog.csdnimg.cn/20210221154521571.png)  
+容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20 行第20 列的数是多少？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/50.\345\255\227\344\270\262\346\216\222\345\272\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/50.\345\255\227\344\270\262\346\216\222\345\272\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5bcce2c729d6e7007ae1cb6d7ac4f8a14ef2bea9
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/50.\345\255\227\344\270\262\346\216\222\345\272\217/solution.md"
@@ -0,0 +1,77 @@
+# 字串排序
+
+#### 问题描述
+小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。  
+在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。  
+例如，对于字符串 lan 排序，只需要 1 次交换。对于字符串 qiao 排序，总共需要 4 次交换。  
+小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 V 次交换，可是他忘了把这个字符串记下来，现在找不到了。  
+请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对该串的字符排序，正好需要 V 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。请注意字符串中可以包含相同的字符。  
+
+#### 输入格式
+输入的第一行包含一个整数V，小蓝的幸运数字。
+
+#### 输出格式
+题面要求的一行字符串。
+
+#### 样例输入
+```
+4
+```
+#### 样例输出
+```
+bbaa
+```
+#### 样例输入
+```
+100
+```
+#### 样例输出
+```
+jihgfeeddccbbaa
+```
+#### 评测用例规模与约定
+```
+对于 30% 的评测用例， 1 ≤ V ≤ 20。
+对于 50% 的评测用例， 1 ≤ V ≤ 100。
+对于所有评测用例， 1 ≤ V ≤ 10000。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/52.\347\237\251\351\230\265/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/52.\347\237\251\351\230\265/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c566426e82df48ff9331bf3830f976ba9dbe3340
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/52.\347\237\251\351\230\265/solution.md"
@@ -0,0 +1,47 @@
+# 矩阵
+
+把 1 ∼ 2020 放在 2 × 1010 的矩阵里。
+
+要求同一行中右边的比左边大，同一列中下边的比上边的大。一共有多少种方案？
+
+答案很大，你只需要给出方案数除以 2020 的余数即可。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/55.\344\272\244\346\215\242\347\223\266\345\255\220/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/55.\344\272\244\346\215\242\347\223\266\345\255\220/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e4cfcb0b904f1dc19f5b138c18197398b9309579
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/55.\344\272\244\346\215\242\347\223\266\345\255\220/solution.md"
@@ -0,0 +1,77 @@
+# 交换瓶子
+
+有N个瓶子，编号 1 ~ N，放在架子上。  
+比如有5个瓶子：  
+2 1 3 5 4  
+要求每次拿起2个瓶子，交换它们的位置。  
+经过若干次后，使得瓶子的序号为：  
+1 2 3 4 5  
+对于这么简单的情况，显然，至少需要交换2次就可以复位。  
+如果瓶子更多呢？你可以通过编程来解决。  
+
+输入格式为两行：  
+第一行: 一个正整数N（N<10000）, 表示瓶子的数目  
+第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。  
+
+输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。  
+
+例如，输入：  
+```
+5
+3 1 2 5 4
+```
+程序应该输出：
+```
+3
+```
+再例如，输入：
+```
+5
+5 4 3 2 1
+```
+程序应该输出：
+```
+2
+```
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/56.\346\216\222\345\256\203\345\271\263\346\226\271\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/56.\346\216\222\345\256\203\345\271\263\346\226\271\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..64efdc42ffd92bae0719b0bf810be23154a41594
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/56.\346\216\222\345\256\203\345\271\263\346\226\271\346\225\260/solution.md"
@@ -0,0 +1,50 @@
+# 排它平方数
+
+203879 * 203879 = 41566646641  
+这有什么神奇呢？仔细观察，203879 是个6位数，并且它的每个数位上的数字都是不同的，并且它平方后的所有数位上都不出现组成它自身的数字。
+具有这样特点的6位数还有一个，请你找出它！
+再归纳一下筛选要求：
+1. 6位正整数
+2. 每个数位上的数字不同
+3. 其平方数的每个数位不含原数字的任何组成数位
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/57.REPEAT \347\250\213\345\272\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/57.REPEAT \347\250\213\345\272\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e0e775f5247b37390d41ec5c45d6e6ad610d5029
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/57.REPEAT \347\250\213\345\272\217/solution.md"	
@@ -0,0 +1,1062 @@
+# REPEAT 程序
+
+附件 prog.txt 中是一个用某种语言写的程序。附件在本文的末尾。
+
+其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达，从次行开始连续的缩进比该行多的（前面的空白更长的）为循环包含的内容。
+
+![](https://img-blog.csdnimg.cn/20210320200704647.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MDEzMjQ3,size_16,color_FFFFFF,t_70)
+
+该片段中从 A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的循环两次中。
+
+REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
+
+A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
+
+请问该程序执行完毕之后，A 的值是多少？
+
+
+
+题目给出的 prog.txt 文件：
+```
+A = 0
+REPEAT 2:
+    A = A + 4
+    REPEAT 5:
+        REPEAT 6:
+            A = A + 5
+        A = A + 7
+    REPEAT 6:
+        A = A + 7
+        REPEAT 4:
+            A = A + 2
+            A = A + 7
+        A = A + 2
+    REPEAT 7:
+        REPEAT 4:
+            A = A + 8
+            A = A + 7
+            A = A + 4
+            A = A + 5
+        A = A + 8
+    REPEAT 8:
+        A = A + 5
+        REPEAT 1:
+            A = A + 2
+        REPEAT 7:
+            A = A + 5
+        A = A + 5
+    REPEAT 2:
+        REPEAT 3:
+            A = A + 1
+        A = A + 1
+    REPEAT 5:
+        A = A + 1
+    REPEAT 9:
+        REPEAT 6:
+            A = A + 5
+            A = A + 1
+        REPEAT 6:
+            A = A + 2
+            A = A + 8
+            A = A + 3
+        REPEAT 2:
+            A = A + 5
+        REPEAT 3:
+            A = A + 9
+        REPEAT 1:
+            A = A + 4
+        REPEAT 2:
+            A = A + 9
+        REPEAT 1:
+            A = A + 6
+            A = A + 6
+            A = A + 4
+        REPEAT 3:
+            A = A + 7
+        A = A + 1
+        REPEAT 2:
+            A = A + 3
+        REPEAT 5:
+            A = A + 2
+            A = A + 5
+            A = A + 2
+        A = A + 4
+    A = A + 3
+REPEAT 4:
+    A = A + 4
+    A = A + 3
+    A = A + 7
+    REPEAT 5:
+        REPEAT 4:
+            A = A + 5
+            A = A + 7
+        REPEAT 5:
+            A = A + 3
+        REPEAT 3:
+            A = A + 3
+            A = A + 1
+        A = A + 8
+        A = A + 2
+        REPEAT 9:
+            A = A + 5
+        REPEAT 1:
+            A = A + 5
+        A = A + 2
+    A = A + 8
+A = A + 6
+REPEAT 3:
+    REPEAT 4:
+        A = A + 9
+        REPEAT 5:
+            A = A + 2
+        A = A + 1
+    REPEAT 9:
+        A = A + 9
+        A = A + 2
+        REPEAT 1:
+            A = A + 6
+            A = A + 8
+        REPEAT 2:
+            A = A + 9
+            A = A + 4
+        A = A + 7
+    REPEAT 2:
+        REPEAT 7:
+            A = A + 3
+            A = A + 5
+        REPEAT 3:
+            A = A + 5
+            A = A + 3
+            A = A + 6
+            A = A + 4
+        REPEAT 9:
+            A = A + 2
+            A = A + 8
+            A = A + 2
+        A = A + 3
+    REPEAT 2:
+        REPEAT 8:
+            A = A + 5
+            A = A + 1
+        A = A + 6
+        A = A + 1
+    A = A + 2
+    REPEAT 6:
+        REPEAT 1:
+            A = A + 3
+        REPEAT 1:
+            A = A + 2
+        REPEAT 4:
+            A = A + 7
+            A = A + 1
+        A = A + 8
+        REPEAT 6:
+            A = A + 5
+        REPEAT 6:
+            A = A + 3
+        REPEAT 2:
+            A = A + 2
+            A = A + 9
+        A = A + 7
+    REPEAT 9:
+        A = A + 8
+        REPEAT 9:
+            A = A + 8
+            A = A + 9
+            A = A + 3
+        A = A + 2
+        REPEAT 6:
+            A = A + 3
+        REPEAT 9:
+            A = A + 1
+        A = A + 9
+        A = A + 5
+        REPEAT 2:
+            A = A + 4
+            A = A + 9
+        A = A + 8
+        REPEAT 5:
+            A = A + 6
+            A = A + 9
+        A = A + 1
+    REPEAT 1:
+        A = A + 4
+    A = A + 2
+    REPEAT 9:
+        REPEAT 3:
+            A = A + 4
+        REPEAT 7:
+            A = A + 8
+            A = A + 3
+        REPEAT 5:
+            A = A + 9
+        REPEAT 8:
+            A = A + 9
+            A = A + 8
+        REPEAT 4:
+            A = A + 7
+        A = A + 7
+    A = A + 3
+A = A + 5
+REPEAT 6:
+    A = A + 7
+REPEAT 7:
+    A = A + 2
+    A = A + 2
+A = A + 1
+REPEAT 8:
+    REPEAT 1:
+        REPEAT 4:
+            A = A + 6
+            A = A + 6
+            A = A + 2
+        REPEAT 5:
+            A = A + 4
+            A = A + 8
+            A = A + 4
+        REPEAT 1:
+            A = A + 5
+        REPEAT 7:
+            A = A + 8
+        REPEAT 6:
+            A = A + 4
+        A = A + 4
+        A = A + 8
+        REPEAT 4:
+            A = A + 2
+        REPEAT 2:
+            A = A + 4
+        REPEAT 2:
+            A = A + 3
+        REPEAT 1:
+            A = A + 2
+        A = A + 8
+        REPEAT 2:
+            A = A + 7
+        REPEAT 8:
+            A = A + 6
+            A = A + 1
+        A = A + 7
+    REPEAT 8:
+        A = A + 2
+    REPEAT 8:
+        REPEAT 6:
+            A = A + 1
+            A = A + 6
+        REPEAT 2:
+            A = A + 4
+            A = A + 1
+        A = A + 7
+    A = A + 4
+REPEAT 4:
+    REPEAT 9:
+        A = A + 2
+    REPEAT 1:
+        A = A + 2
+    A = A + 5
+REPEAT 8:
+    REPEAT 6:
+        A = A + 3
+    REPEAT 4:
+        A = A + 1
+        A = A + 6
+        A = A + 1
+    REPEAT 7:
+        A = A + 7
+        REPEAT 7:
+            A = A + 3
+            A = A + 9
+            A = A + 1
+            A = A + 9
+        REPEAT 3:
+            A = A + 5
+        A = A + 5
+        A = A + 6
+        A = A + 2
+    REPEAT 1:
+        A = A + 4
+    REPEAT 2:
+        A = A + 7
+    REPEAT 1:
+        A = A + 7
+        REPEAT 4:
+            A = A + 7
+        A = A + 2
+        REPEAT 5:
+            A = A + 9
+            A = A + 1
+            A = A + 9
+            A = A + 5
+            A = A + 9
+        REPEAT 5:
+            A = A + 5
+        REPEAT 1:
+            A = A + 6
+        REPEAT 2:
+            A = A + 3
+            A = A + 2
+            A = A + 6
+            A = A + 8
+            A = A + 8
+            A = A + 7
+        A = A + 5
+    A = A + 5
+REPEAT 2:
+    A = A + 1
+    A = A + 7
+A = A + 3
+REPEAT 2:
+    A = A + 7
+A = A + 1
+A = A + 4
+REPEAT 1:
+    REPEAT 7:
+        REPEAT 2:
+            A = A + 3
+            A = A + 5
+            A = A + 2
+        A = A + 6
+    A = A + 1
+A = A + 2
+A = A + 4
+A = A + 9
+REPEAT 1:
+    A = A + 8
+REPEAT 8:
+    REPEAT 4:
+        REPEAT 8:
+            A = A + 4
+        REPEAT 3:
+            A = A + 1
+            A = A + 8
+        REPEAT 7:
+            A = A + 8
+        REPEAT 7:
+            A = A + 7
+        A = A + 7
+        REPEAT 7:
+            A = A + 6
+        REPEAT 5:
+            A = A + 9
+        A = A + 3
+        REPEAT 4:
+            A = A + 5
+        A = A + 5
+    A = A + 4
+    REPEAT 9:
+        REPEAT 3:
+            A = A + 4
+            A = A + 3
+            A = A + 6
+        REPEAT 1:
+            A = A + 3
+            A = A + 3
+            A = A + 6
+        REPEAT 6:
+            A = A + 7
+            A = A + 7
+            A = A + 5
+            A = A + 5
+            A = A + 1
+            A = A + 2
+        A = A + 6
+        A = A + 6
+    REPEAT 9:
+        A = A + 6
+    REPEAT 1:
+        REPEAT 2:
+            A = A + 4
+            A = A + 7
+        REPEAT 3:
+            A = A + 6
+        REPEAT 5:
+            A = A + 3
+        A = A + 6
+        REPEAT 9:
+            A = A + 3
+        A = A + 6
+    REPEAT 5:
+        A = A + 8
+        A = A + 8
+        REPEAT 3:
+            A = A + 7
+            A = A + 9
+            A = A + 8
+            A = A + 3
+        A = A + 3
+    A = A + 9
+REPEAT 6:
+    A = A + 9
+A = A + 1
+REPEAT 4:
+    REPEAT 1:
+        A = A + 7
+    REPEAT 9:
+        A = A + 2
+        A = A + 9
+    A = A + 1
+A = A + 2
+A = A + 8
+A = A + 7
+A = A + 9
+A = A + 6
+REPEAT 4:
+    REPEAT 2:
+        A = A + 3
+    REPEAT 3:
+        A = A + 4
+    A = A + 4
+REPEAT 6:
+    A = A + 6
+A = A + 1
+A = A + 5
+A = A + 8
+REPEAT 2:
+    A = A + 6
+    REPEAT 1:
+        REPEAT 2:
+            A = A + 2
+        REPEAT 3:
+            A = A + 1
+        REPEAT 1:
+            A = A + 8
+            A = A + 7
+            A = A + 4
+            A = A + 2
+            A = A + 8
+        A = A + 4
+    REPEAT 5:
+        REPEAT 6:
+            A = A + 8
+        REPEAT 9:
+            A = A + 5
+        A = A + 5
+    REPEAT 5:
+        A = A + 5
+    REPEAT 3:
+        REPEAT 5:
+            A = A + 4
+        REPEAT 4:
+            A = A + 6
+            A = A + 3
+        REPEAT 7:
+            A = A + 3
+            A = A + 3
+            A = A + 1
+            A = A + 7
+            A = A + 7
+            A = A + 6
+            A = A + 5
+            A = A + 5
+        A = A + 6
+    REPEAT 1:
+        A = A + 9
+    A = A + 3
+    REPEAT 1:
+        REPEAT 1:
+            A = A + 1
+        REPEAT 8:
+            A = A + 5
+        REPEAT 8:
+            A = A + 6
+        REPEAT 4:
+            A = A + 9
+        A = A + 4
+    REPEAT 2:
+        A = A + 3
+        A = A + 7
+        REPEAT 5:
+            A = A + 7
+            A = A + 5
+            A = A + 8
+        A = A + 7
+        A = A + 8
+    A = A + 5
+    REPEAT 2:
+        A = A + 5
+    A = A + 7
+    A = A + 8
+A = A + 5
+A = A + 9
+REPEAT 2:
+    REPEAT 6:
+        A = A + 9
+        A = A + 1
+        A = A + 8
+        A = A + 7
+        A = A + 1
+        A = A + 5
+    REPEAT 3:
+        A = A + 3
+        A = A + 9
+        A = A + 7
+    REPEAT 3:
+        A = A + 9
+    A = A + 1
+    REPEAT 6:
+        A = A + 1
+    REPEAT 9:
+        REPEAT 7:
+            A = A + 3
+        REPEAT 5:
+            A = A + 5
+            A = A + 8
+            A = A + 8
+            A = A + 1
+            A = A + 2
+        REPEAT 4:
+            A = A + 6
+        REPEAT 3:
+            A = A + 3
+        A = A + 7
+    REPEAT 8:
+        REPEAT 1:
+            A = A + 7
+        A = A + 8
+        A = A + 3
+    A = A + 1
+A = A + 2
+A = A + 4
+A = A + 7
+REPEAT 1:
+    REPEAT 1:
+        REPEAT 1:
+            A = A + 4
+            A = A + 6
+        REPEAT 1:
+            A = A + 3
+            A = A + 9
+            A = A + 6
+        REPEAT 9:
+            A = A + 1
+            A = A + 6
+        REPEAT 5:
+            A = A + 3
+            A = A + 9
+        A = A + 5
+        A = A + 5
+    A = A + 7
+    A = A + 2
+    REPEAT 2:
+        A = A + 7
+    A = A + 7
+    REPEAT 7:
+        REPEAT 4:
+            A = A + 6
+        A = A + 8
+        REPEAT 6:
+            A = A + 6
+        REPEAT 2:
+            A = A + 1
+        A = A + 7
+        A = A + 6
+    A = A + 7
+    REPEAT 4:
+        REPEAT 7:
+            A = A + 1
+        REPEAT 2:
+            A = A + 2
+            A = A + 5
+        A = A + 8
+    A = A + 2
+A = A + 1
+A = A + 4
+REPEAT 8:
+    A = A + 5
+A = A + 6
+REPEAT 7:
+    REPEAT 6:
+        REPEAT 9:
+            A = A + 7
+            A = A + 8
+        REPEAT 4:
+            A = A + 6
+            A = A + 4
+            A = A + 3
+            A = A + 6
+        REPEAT 9:
+            A = A + 3
+        REPEAT 9:
+            A = A + 2
+        A = A + 7
+    A = A + 5
+    A = A + 2
+REPEAT 7:
+    REPEAT 8:
+        REPEAT 6:
+            A = A + 4
+            A = A + 9
+            A = A + 5
+            A = A + 3
+        A = A + 9
+    REPEAT 4:
+        REPEAT 1:
+            A = A + 6
+            A = A + 8
+        REPEAT 1:
+            A = A + 6
+        A = A + 4
+        A = A + 6
+    REPEAT 3:
+        A = A + 7
+        REPEAT 3:
+            A = A + 4
+            A = A + 4
+            A = A + 2
+        A = A + 3
+        A = A + 7
+    REPEAT 5:
+        A = A + 6
+        A = A + 5
+    REPEAT 1:
+        REPEAT 8:
+            A = A + 5
+        REPEAT 3:
+            A = A + 6
+        REPEAT 9:
+            A = A + 4
+        A = A + 3
+    REPEAT 6:
+        REPEAT 2:
+            A = A + 1
+        A = A + 5
+    A = A + 2
+A = A + 2
+A = A + 7
+REPEAT 4:
+    A = A + 7
+A = A + 9
+A = A + 2
+REPEAT 8:
+    A = A + 9
+    REPEAT 9:
+        REPEAT 2:
+            A = A + 3
+            A = A + 2
+            A = A + 1
+            A = A + 5
+        REPEAT 9:
+            A = A + 1
+            A = A + 3
+        A = A + 9
+        REPEAT 7:
+            A = A + 2
+        REPEAT 5:
+            A = A + 9
+            A = A + 3
+        REPEAT 2:
+            A = A + 4
+        REPEAT 8:
+            A = A + 9
+        REPEAT 5:
+            A = A + 5
+            A = A + 4
+        A = A + 2
+    A = A + 4
+    REPEAT 6:
+        A = A + 2
+        REPEAT 5:
+            A = A + 7
+            A = A + 7
+            A = A + 8
+            A = A + 3
+        REPEAT 8:
+            A = A + 2
+            A = A + 5
+        REPEAT 1:
+            A = A + 8
+            A = A + 5
+            A = A + 1
+            A = A + 1
+        A = A + 5
+        REPEAT 2:
+            A = A + 6
+        REPEAT 6:
+            A = A + 9
+            A = A + 2
+        A = A + 5
+        REPEAT 4:
+            A = A + 7
+        A = A + 1
+        REPEAT 6:
+            A = A + 8
+        A = A + 4
+    REPEAT 3:
+        REPEAT 2:
+            A = A + 1
+            A = A + 5
+        REPEAT 2:
+            A = A + 7
+        REPEAT 9:
+            A = A + 6
+            A = A + 8
+            A = A + 9
+        A = A + 5
+    REPEAT 9:
+        REPEAT 3:
+            A = A + 7
+            A = A + 7
+        A = A + 9
+        A = A + 7
+        REPEAT 5:
+            A = A + 7
+            A = A + 2
+        A = A + 1
+    A = A + 8
+    A = A + 3
+    A = A + 5
+A = A + 1
+REPEAT 8:
+    A = A + 4
+A = A + 2
+A = A + 2
+A = A + 8
+REPEAT 4:
+    REPEAT 4:
+        A = A + 8
+        REPEAT 7:
+            A = A + 5
+            A = A + 2
+        REPEAT 2:
+            A = A + 6
+        REPEAT 4:
+            A = A + 8
+            A = A + 6
+        A = A + 1
+    A = A + 3
+A = A + 2
+A = A + 7
+A = A + 4
+REPEAT 8:
+    A = A + 2
+    A = A + 4
+REPEAT 5:
+    REPEAT 3:
+        REPEAT 6:
+            A = A + 8
+            A = A + 1
+        A = A + 6
+    A = A + 5
+    A = A + 9
+REPEAT 8:
+    A = A + 7
+REPEAT 6:
+    A = A + 4
+A = A + 5
+REPEAT 3:
+    A = A + 1
+    REPEAT 1:
+        REPEAT 5:
+            A = A + 6
+        A = A + 2
+    REPEAT 9:
+        REPEAT 5:
+            A = A + 9
+            A = A + 3
+        REPEAT 9:
+            A = A + 9
+        A = A + 8
+    REPEAT 8:
+        REPEAT 5:
+            A = A + 9
+            A = A + 4
+        REPEAT 9:
+            A = A + 3
+        A = A + 4
+    A = A + 5
+REPEAT 9:
+    REPEAT 7:
+        A = A + 5
+    REPEAT 3:
+        A = A + 7
+    REPEAT 9:
+        REPEAT 6:
+            A = A + 4
+        A = A + 6
+    REPEAT 5:
+        REPEAT 6:
+            A = A + 5
+            A = A + 3
+        A = A + 3
+    A = A + 3
+    A = A + 5
+    REPEAT 7:
+        A = A + 5
+        REPEAT 2:
+            A = A + 5
+            A = A + 6
+        REPEAT 2:
+            A = A + 2
+        A = A + 5
+    A = A + 3
+A = A + 5
+A = A + 5
+REPEAT 4:
+    A = A + 2
+    A = A + 1
+    REPEAT 9:
+        A = A + 9
+        A = A + 5
+        A = A + 6
+        A = A + 2
+        A = A + 2
+        A = A + 5
+    REPEAT 9:
+        A = A + 5
+    A = A + 4
+    REPEAT 4:
+        REPEAT 4:
+            A = A + 1
+            A = A + 2
+        REPEAT 6:
+            A = A + 9
+            A = A + 3
+        REPEAT 2:
+            A = A + 5
+            A = A + 1
+            A = A + 1
+            A = A + 3
+        A = A + 8
+        REPEAT 7:
+            A = A + 4
+        REPEAT 6:
+            A = A + 9
+        REPEAT 5:
+            A = A + 9
+            A = A + 8
+            A = A + 3
+        A = A + 9
+        A = A + 4
+    A = A + 6
+REPEAT 7:
+    A = A + 9
+REPEAT 9:
+    A = A + 4
+    A = A + 9
+    A = A + 1
+    A = A + 3
+    REPEAT 5:
+        REPEAT 1:
+            A = A + 4
+            A = A + 4
+        REPEAT 8:
+            A = A + 9
+            A = A + 6
+            A = A + 2
+        REPEAT 3:
+            A = A + 4
+            A = A + 4
+        REPEAT 3:
+            A = A + 5
+            A = A + 2
+            A = A + 8
+            A = A + 3
+            A = A + 6
+            A = A + 4
+            A = A + 9
+            A = A + 1
+        A = A + 9
+        A = A + 5
+        A = A + 3
+        REPEAT 3:
+            A = A + 2
+            A = A + 5
+            A = A + 8
+            A = A + 2
+        A = A + 5
+    REPEAT 8:
+        REPEAT 2:
+            A = A + 6
+        A = A + 7
+    A = A + 6
+    A = A + 9
+    A = A + 2
+REPEAT 2:
+    A = A + 3
+    REPEAT 8:
+        A = A + 7
+        A = A + 2
+        A = A + 1
+        A = A + 4
+        A = A + 1
+        A = A + 5
+    A = A + 2
+    A = A + 1
+    REPEAT 1:
+        A = A + 1
+    REPEAT 6:
+        A = A + 4
+        A = A + 3
+    A = A + 3
+    REPEAT 5:
+        A = A + 3
+    REPEAT 6:
+        REPEAT 1:
+            A = A + 5
+            A = A + 7
+            A = A + 7
+            A = A + 7
+        REPEAT 5:
+            A = A + 9
+        A = A + 7
+        REPEAT 5:
+            A = A + 9
+            A = A + 1
+            A = A + 9
+        A = A + 8
+        REPEAT 1:
+            A = A + 2
+        REPEAT 5:
+            A = A + 8
+        REPEAT 3:
+            A = A + 2
+            A = A + 9
+        A = A + 6
+        A = A + 3
+    REPEAT 5:
+        REPEAT 6:
+            A = A + 5
+            A = A + 5
+        REPEAT 4:
+            A = A + 5
+        A = A + 4
+        REPEAT 8:
+            A = A + 9
+            A = A + 1
+        REPEAT 8:
+            A = A + 8
+            A = A + 1
+        A = A + 4
+        REPEAT 6:
+            A = A + 6
+        REPEAT 2:
+            A = A + 3
+            A = A + 9
+            A = A + 6
+            A = A + 9
+        REPEAT 1:
+            A = A + 4
+        REPEAT 3:
+            A = A + 3
+            A = A + 4
+            A = A + 2
+            A = A + 8
+        REPEAT 2:
+            A = A + 4
+        A = A + 1
+        REPEAT 9:
+            A = A + 2
+        A = A + 9
+    A = A + 7
+REPEAT 7:
+    REPEAT 7:
+        REPEAT 5:
+            A = A + 7
+        REPEAT 5:
+            A = A + 1
+        A = A + 1
+    REPEAT 5:
+        A = A + 6
+        REPEAT 1:
+            A = A + 4
+        REPEAT 9:
+            A = A + 4
+        A = A + 1
+    REPEAT 6:
+        A = A + 8
+        A = A + 5
+        REPEAT 1:
+            A = A + 4
+        REPEAT 5:
+            A = A + 8
+            A = A + 7
+        A = A + 2
+    REPEAT 3:
+        A = A + 3
+    REPEAT 8:
+        REPEAT 8:
+            A = A + 4
+        A = A + 7
+        REPEAT 5:
+            A = A + 1
+        REPEAT 8:
+            A = A + 7
+            A = A + 8
+            A = A + 4
+        A = A + 7
+        A = A + 6
+    A = A + 9
+    A = A + 5
+REPEAT 3:
+    A = A + 5
+    REPEAT 9:
+        A = A + 1
+    A = A + 7
+REPEAT 1:
+    A = A + 8
+A = A + 4
+REPEAT 8:
+    REPEAT 7:
+        A = A + 2
+        REPEAT 4:
+            A = A + 6
+        A = A + 6
+    REPEAT 1:
+        A = A + 7
+    A = A + 1
+REPEAT 9:
+    REPEAT 5:
+        A = A + 6
+        A = A + 5
+        REPEAT 7:
+            A = A + 3
+            A = A + 6
+        A = A + 8
+    REPEAT 2:
+        A = A + 7
+    A = A + 1
+    A = A + 9
+    REPEAT 3:
+        REPEAT 3:
+            A = A + 5
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/59.\346\230\216\347\240\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/59.\346\230\216\347\240\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bb2254a78d29390d8fff25eea4dca4c40c936b89
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/59.\346\230\216\347\240\201/solution.md"
@@ -0,0 +1,74 @@
+# 明码
+
+汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。
+
+16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。
+
+一个字节可以存储8位信息，用32个字节就可以存一个汉字的字形了。
+
+把每个字节转为2进制表示，1表示墨迹，0表示底色。
+
+每行2个字节，一共16行，布局是：
+
+第1字节，第2字节  
+第3字节，第4字节  
+…  
+第31字节, 第32字节  
+
+这道题目是给你一段多个汉字组成的信息，每个汉字用32个字节表示，这里给出了字节作为有符号整数的值。
+
+题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形，从中看出题目的要求，并根据要求填写答案。
+
+这段信息是（一共10个汉字）：
+```
+4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 
+16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16 
+4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 
+0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4 
+4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64 
+16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128 
+0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0 
+2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0 
+1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0 
+0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/60.\344\270\211\344\275\223\346\224\273\345\207\273/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/60.\344\270\211\344\275\223\346\224\273\345\207\273/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..262846e1030f95444068047ab545f57cc6f947f8
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/60.\344\270\211\344\275\223\346\224\273\345\207\273/solution.md"
@@ -0,0 +1,83 @@
+# 三体攻击
+
+#### 题目描述
+三体人将对地球发起攻击。为了抵御攻击，地球人派出了 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 $描述；
+所有满足$ i ∈ [la_t, ra_t],j ∈ [lb_t, rb_t],k ∈ [lc_t, rc_t] $的战舰 (i, j, k) 会受到 $h_t$ 的伤害。如果一个战舰累计受到的总伤害超过其防御力，那么这个战舰会爆炸。
+
+地球指挥官希望你能告诉他，第一艘爆炸的战舰是在哪一轮攻击后爆炸的。
+
+#### 输入格式
+从标准输入读入数据。
+第一行包括 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
+1 2 1 2 1 1 1
+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；
+对于 40% 的数据，A × B × C, m ≤ 10, 000；
+对于 70% 的数据，A, B, C ≤ 200；
+对于所有数据，A × B × C ≤ 10^6, m ≤ 10^6, 0 ≤ d(i, j, k), ht ≤ 10^9。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/61.\345\255\227\346\257\215\351\230\265\345\210\227/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/61.\345\255\227\346\257\215\351\230\265\345\210\227/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..08a29f9668c4d0bfda4315101535eb9ae0b2e53b
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/61.\345\255\227\346\257\215\351\230\265\345\210\227/solution.md"
@@ -0,0 +1,164 @@
+# 字母阵列
+
+仔细寻找，会发现：在下面的8x8的方阵中，隐藏着字母序列：“LANQIAO”。
+```
+SLANQIAO
+ZOEXCCGB
+MOAYWKHI
+BCCIPLJQ
+SLANQIAO
+RSFWFNYA
+XIFZVWAL
+COAIQNAL
+```
+我们约定: 序列可以水平，垂直，或者是斜向；并且走向不限（实际上就是有一共8种方向）。
+
+上面一共有4个满足要求的串。
+
+下面有一个更大的（100x100）的字母方阵。
+
+你能算出其中隐藏了多少个“LANQIAO”吗？
+
+我就把这些东西放在了txt文件里
+```
+FOAIQNALWIKEGNICJWAOSXDHTHZPOLGYELORAUHOHCZIERPTOOJUITQJCFNIYYQHSBEABBQZPNGYQTCLSKZFCYWDGOAIADKLSNGJ
+GSOZTQKCCSDWGUWAUOZKNILGVNLMCLXQVBJENIHIVLRPVVXXFTHQUXUAVZZOFFJHYLMGTLANQIAOQQILCDCJERJASNCTLYGRMHGF
+TSDFYTLVIBHKLJVVJUDMKGJZGNNSTPVLCKTOFMUEUFSVQIAUVHNVFTGBDDARPKYNNCUOYUAZXQJNOEEYKLFRMOEMHUKJTPETHLES
+FKVINSLWEVGAGMKVFVIUBMYOIAFHLVNKNTYKTZWVXQWRWIGPENFXYDTKRVPKRTHMGHVYOCLDCKMEKRLGEKBYUCLOLYPAKPFSOREH
+KWPUOLOVMOFBIXYACWRDYBINTMPASPCEOKHXQIGBQQMCEOIVULIEOPFSCSIHENAJCVDPJDOIWIIULFDNOZOFVAMCABVGKAKCOZMG
+XWMYRTAFGFOCNHLBGNGOXPJSTWLZUNNAGIRETGXFWAQSSJPFTQAXMTQWMZWYVEPQERKSWTSCHSQOOBGXAQTBCHOEGBDVKGWJIFTG
+ZWWJEIISPLMXIMGHOOGDRZFTGNDDWDWMNUFWJYJGULPHNUFSAQNNIUVAAFZIAZKFXXNWCEABGJAUMGYEIEFVQXVHHHEDYUITRCQB
+XZHDPZQTOBECJVBZLACVXACZEDYOGVAVQRNWEOWGRAQYUEUESTEDQTYJUTEFOOITSHDDZHONJGBRCWNEQLZUTBNQIADKNFIOMWZR
+EBFKCVNLURZSNPOLTISRPDTNUMCDGKTYRGIOVEPTUTSBAWQKWWEUWIWHAANUZUADGZEATZOQICWFUJTWNZDBKLQNELWVTBNDLNFH
+PESISEATZNCDFRMXBQUKBFTIGYSFCWVHPMSUSDKPSCOMVLDOHYQVFHAJKRDTAVLIMNZBZSMLMRTLRPSLAHXDBASDMWAAYBPYVJZF
+SCCWYHLQOUKBMCEYENQNJXFOMOOJMTKDSHJJOHDKEGATFZHGWJJAZJROWHAZUFGEQKPYXLCAAXHHQBDALPYUDWZQHBASBBCFGQCQ
+ZKNXUBRYZVSPQHOVLAEUAUITMPWXNXJQVIBJVBCSVXKWFAFRPRWOLYVSDVTGGOFFMNQJZOBUDJLFHJTCYMPNOBHQJHGKLIKLZMLA
+POCKVEQXUAVHERIAQLGJHYOOVOMTXQFRTBFSETOZICPCHZHFBWNESVJJLSVSVOOGYYABFESWNWDNYBGBNAKRCFQMTCUMIFTESVIN
+JCAULIQRYUMAMAOVVWSEUTMECXSDTONRMMROQUISYEURSAYNZUVOPXLIFBDOHPXMABBLEQZGLJXQJOEYYRRRCFTEZQAOIWKRJQDL
+ZNUUDWZXZZURPMHGXQGNQBIQWWNERZWULSAPIBODBFFQQIHEQKCKLJYQNXQUTAAYGRBXSLLQNOQPZJEWHETQHPXJANMJFOHINWOW
+KJGAWWFSVIZHFNUWBLWYVPIWAEICCAHOEIWRADSLOZGPSVGPUBUUQAVYCHOIGINKYKJABWAQCZCXOBKTNJZQRHLUFKQLACAAOIWJ
+SIKWLXQHKDFJVGBVXWDWJKUSFRQRTDJYQMNFOQQALHRLMHSDMCFLAOVKDMTKMTPVTLAZLYJNJXZCFRHHSDIXYUUSVIMIICLUJHFW
+JHWUSMCFYHPIXHAPBBSHYDQCKVGQFTENLVERFVOVDCLSTQFUSEPUMTFODLZLYQXDOXAEPONIQWTDWSAWBNSZYACGSJQSHAUMIKXT
+MVBNFXMFNPAYSODPXEAYNRKTEZJWMUACSIUYPIORUFPMXAOZZJPJXPFLNSKNIAMETMOVULZPQIJJIRCSYQXOEVRHCNACSBRHKYNW
+KGKBTBHGWKVJYZCOVNSKUREKZEIWVLOHAMUAYKLUGHEUESICBZAHURNTJAECTHRNKSIJQFIPVZANSZYSPJWHPKHCAPEYWNXUYQSD
+RRRFYQFIQSWYRQTSNGNUFOBMSLGAFWPJGYEHGASFKTJCCZPXFIQLSXNKNWCYVTETOAPCOZJNHEWOCCAWVDEZUQCLLAVUQJJTQCKJ
+NMBKMUENVGXXVMQCLXPJDQIQCFWYADIFDSGINGZDJYHPUPXVRMWDIPJRWPNRYOFGYYPEAVKDEMLYRRRMNCRQXPTDSQIVKKGJWDEF
+SBAEKIFZCKDOMIQKBDWVQGBYWPDIBOLQUGAQRXLJDAZMXVZXYSNWEWTNZKYREMBEUHOTFOCKEJSXCMUBCKXNGQXTQJRCRCLWJTOI
+YXBFBIBRAAFNPKBLTSMCFERZURZNWHMOEHIHNQTBWXNPJGIDYDPRGEWACCBULJRACOFLANQIAOIHMYCNQHVKXSIGAMWAHUSNBBTD
+QDGPTRONXHAZWOUPNBFJFEWAMFZUQZFDKAPNJUBQPWBPYGPZHKUDZZDLCCWHGAUKJCSLLFWGPYJKJQBNLCZESOGXXSQCVVKVRVAW
+NXPGQOUEFLUZHHSAODIWEPZLXVQLYGVOOVCCREDJZJOMCSCFFKEIEAVCTPUZOWNOLJHGBJHJFBFFORGXOXXFOCAGBWEFCIDEKDLB
+PTXSUINQAJURNFQPMMSPLZTQAHCIOFJUEFFZGIHTSJNIEXQLLHRQUXXLLORJEHGQJOXSLIAVFPEJNGMMVAXDDMPXLOSTRLLFLYRM
+JQNCLENGTROIKDWBMXRNJYPGZRQOREPJJPTXKVVKPYYZENEOIQKZOPXAYGFXORXRIDGATHMZFDJIOIOKVDJBHSXQMYCBYFGXWHLH
+CITGTILGPGBHZMNWWHXEFPGDPJUVFBJKAQWACZHPRPJYCOLGZTBDCVHNRSUAJUQAWAPMQJDQIFPZQZEONWHIYKMXDZOMVETEFJRB
+RDOTIDCFEESOKYPYCGQQKOGPMGJRITSVTKOKDSXLRLJRRHNFRFXCMDNQMCEGZFJWHZOAFBQXXPXNBSWTSUYPAWQRHAUGLNPBRSJT
+HOWRIUGMOQTUYIHDWJRFBWWKWYKCICSVBVKTBIIWGFSVIFCTUKIHHUUISCOTEOYRWQXTAEBXQQOLLMOALNIYVCCHNSWIKHMYYNZO
+OFRIYYXPPSRTPAYMUJSSDILKIZAYSEIOLANQIAOVKARDPGVFCSYBSNHAPGTIKLAWTTKOEADWRLAACAAFYTBTNSGFTYLYUHJXBMMA
+NJFTMLUIBKDPWBXQOMBVQXCZOIREHRSZCSJOIVBXWQIBUTYBQNTZRVROHGOIZYAJWXLEATLOZJIKJMIHSLGSVTCXJWIOOGWSERRQ
+DBQJNGBLRIYFIKHBEYOZQBOAGGNIZKFDHWXCFNJLBQXVLHIQNIBZSDLTTRERHNWCMLJCVBBGGAQTPUQHIRABXPQSYGSDVMBNNDFG
+KPLFUYXHYGOCZPPXMWCZYNKCYBCRZVKFBHQXPGPBZFTTGEPQTJMOFHAYSQQZDMQECGXOXADYHNNXUKNBXZBYHBOULXNBJZKIZREF
+LVHAMSNXJOCVRPVGJUWXFVOCUCLCZDXRPBBDRLRAVVNLOZWOHWMXYSNMXAKJYWYGILNGUJGIPKAUDVANZLFWKUWWUSQYBRCBVDIJ
+QCXPLOTPPGXCUZOUSSTXHVMLHVMJTUSSOPLRKEBQSGWNGVHKANVZWYQHSHLIPWSYCPKTUKPMWPLVFLLAHXZQANFXHFNYHIQVIOYN
+ZPTJJCBHXPSUPOMNRVCKXSUFCNRCRNCPTPGIDQOEQUDFNUNMJPOEKVIMUJAJZOUKMAFSLDWYMCHTSNJYUDJAHQOIXPYSRHVAFFCR
+DCGMEEWXWMNOSSJNIZCINRHENPPPCYVFWYCONOPKXMFZXXIHNXIGAHAMHSBRESOETGVXWDNQLGCEOUDDJXHQIVCHRNKBFFEWILGY
+SOAIQNALXRBSGAQIDQVMVDKVZCPMJNXKXRXPFZAUVQPBHHQKTPDSQROLQTUGMFQRWGVEWCYPDYDZGNNNUFKJUEHJKPLIQNRQYXHU
+GKGWUCJXUKAEHLRLNDFUQPSJAZTVJRXWXQVBMRJXULEMJJPDCVTOWVFDBVLSBHZRRQUVMUQYKTJCLSGGHGCPHPHMWYAECLJIZUWV
+QQNKPQRJMSOCEAYDNKPHVEGKAGCKAPDXTGVXULHUXHJPDXCSKQTCJENVTZTMRUENCSWHBEORALSREBWAJEMQDXMRKGHJGICDHKHY
+YNSDSWDRLBBFUFVVICMGUCGBSVDLJNXGKXNFGVLKAVBJRRRUHKRXTPBJAKIEBAVMDIOJLIUDABCGNPNJIYBCXMOOWKRPHPYSWRDC
+BORWTNBISSLTVKBRTLWKRNCEDCNEGCIYJIPDICFAVNOISYAHWBLGMNFKXZYTTWJOBEPNMSJEJMHXVPGOJOLQQQVXFGEULANQIAOD
+OQETOJHCZXGTUKIWGMEVVMXCURISUOFQSAWZWDMZWVYHZMPEIMWKJDGERODVVUXYRTYLCRGYQQOIOFZSSZRAIESWBQOAIQNALJNR
+HEYWHPLLPCUEOCBAOWGAYEJZQJHLVNMVQNSQQGGUBOIMDPFLOVSQGBLYAMBRYJDVOXOQINLJAVYALAKHPKOYNKGXIISSJNGKHYMS
+IQVRYKXCUFIRNENEXFJTMOTJWYXSMTDHHPRHWIXETWVVIXZELKLLWRWQYGBCGJNYSUQEFCOUDNIJMLJNLAWSYJGULKBCFPYVSSMW
+WQHGWRQFWFOTGPBBSJBDUKOMBXNRPIMCGPGVZFADWTBVIEMVTBXVAFQDDMJALCOMZTXUFFKBQQZDFAMTFWEXTHBKNWRLUVITQXLN
+OPPJQKNGHWWPENVQIABJCQNKXNPWOWRFEOKQPQLANQIAORGGOLAYCEGZBHZVLPBERWYIJNJUNXKULUQOJLTNRDZDEYWEMYCHJLLB
+LJISOAQLXJEFXVTOZSICOLQIJEXUANJWIFSIMGUQWHBXUDWOEILYFUZTGDZDSPLZPDPXBLFAXLEFQFEPDSJQWEQMXKKHCXHMSATM
+UMUJENPBYKZLWAJAXJKDIYCBREBPOETQHMRHLKSEZUIPRGWIZDDQLSJAPKPBWMJMPZWLNFLFCQOCDBMLIHIYCXUJLFLPZVGWBKMY
+WHZJLKEWUPETVUREKVKCLBNYFLWCERVIPUDINNWGQTUHWXCTDVTMYATYUZLMVLOHKBOGIZCQDOWFBCWJAVUXYUEVRKPOXCKHAWZC
+RPLNLCUHJRADHJNSDPZXIKXGUKEJZCFJQASVUBSNLXCJXVCJZXGMRYRLOBCNGPDUJQVEFKMYHNZGZOAIQNALQDHTBWJXPKJLFXJY
+MKCEZEDAFGSOCORWJGMOKWPVVBVDYZDZHPXFWJBDELHPGOQHMBAHUUUJMGXAEKZCTQTBXNVYUIQUVZGXSKQXJWRUPSFIJDYIAORC
+GKFKQNXPJWOPPBTUKTHUBIROSYOVFEMJBRREWICJPCIOSTWPAUSKTRQULXPWRSXHSRYBCWYCYOTCTPFSQLDIILIGMEVZKYSOYRPH
+SFDSCSMLLNARCCGCBJOGZAEQTGNGSFAQIXLPDBSWZDTYVASYYPVBRFBTIAGGWONGSVKCJDBBLYKAIOXUATGMALZXFOHZFTXALCFU
+CUSSTLCRYPDTFSFJFENKJWTEBOBEPLSNXLALQWCKSLVMZQDJITHZKVCCQXTEXOSVAUFYAZXJUOAPPVEEWOIIMOSZZMCOQBRUXWKG
+PDOFSCKKJJTRYRWGLEZODQTJSIMXIAOLNMLPHBAYLPTTLPYWILSEIIQVSXNHIJEORVCNJHYXRBIZZJTADGMRTSXVRXYGVQQNUEIC
+IHNJOQXUXTXFPALCHOELNVMWDWQTEARUKPIFWXJSMWZLMNLAODUTKNZDYRFRLGBLIBGIBXJBOYMLYLANQIAORORYKSJPOOOAMVRN
+IWIUHLYJKTQGVJBDPROSRGZUFITDIBCDPICNEFIGHWGSROWBYKUCLCQYLJXLHLXSCTJWKDLHHMLDBZCVDKPXYYASHUUMUJMVSXAD
+GXOYXQFEBFIEJJLHBNGSYALOUXNQBXXZAAZJXENJJVVGFVHOTKSLEGLJVSJCQHSSZFEIOGBOGWSPIRENQAAWRQFBEFEXBKGMSTRC
+PYIANSGMNKBCDPHWDUPKICQEUDNZPNGRUJYSZIRLXGXXITAFBCANGDLVAQLDPVTJNSAUZMBBNOBBOERSHQIOLBVTSPPJKVCMXUBS
+IKMDIYSNCJZKJKJQMTIKEPRUNAHJUSWJHSLWIVWHYAYLOIOGSZVWKQWXZDBPHWZRAIPMXDJHBIISVJWVEVZAEGAKCYYMNZARBZPC
+DLDFVQDFDMVHYVOWEKMFKWUXLTPWIVKPRZZXOLMDAPAIQEKJHCHYAGJDBOFWDGNEGQGOOKWSKLTLREMGGTVJFHAIBCQKNZVRCZYS
+FBQASGNCCBBGNKJHCDBTGBIIWKMPHDABKEWDEPYEAVKNMPATUZZUOEHGUGAZNECSGUCIIJPMMRAMTVADMTCRJCBWDLWWFNFOWMVZ
+XFJFBGDAVGGAIZHAUIYENDZTRUWHPQUFWCHOXNCWYNAWVPLBLNQKQDTKQQKXNFXCTBGRWUZFHNRBDNLNKQVOLLGBBJQIYOBCEIKO
+CURAGWXMLYBSIZLAXFONZZMQMRNNSRQKRHQGFGZUTLONAYRKSSOWAMKZBSGOOYQDPTBHGPBNQEDCZHRTOXREOFJEKJVIZXZBCJPN
+KGYBZTZRKOGBETJRUWRNUCIFKIMCZGYTZLCZYGCGKVZRJIFZQIQPTCPPUHYWIXBOFFGSGSAIMNGKKUUROAVNJUQQNSWJRZIZEHAF
+DDAOBVCPOVODVJFLSNPJXHWQBHILWZAHQQMTQASNADZLZNXJLJMFCOUWOZJCMVVTYCKTUBABWLCEBNYWAMOLNBQQYBRUJCQCZALE
+TVVRPMYFIKINHIUEJBDLTCUMMUWICIUVCZNIQIUEWVAHLANQIAONMEYJWPDAFXVNOSOFDOCESSLGZPTJINBUAFWWWMPTYALZIGVD
+DCZGKILMBFXIQQFEKJBIUDEMIFCANVGNYZAYSQFMNNQFEPZFUUVGTBKSMDXITBLANQIAOQUKTPNYPOWSQQYWWMJHSDYVFDJYXBAF
+VGYXAMDRRZWVIHNQPZZWRNWBTROOJOLNUGXBILZKQEGIQSYGKZGODPWBJSCMRRWSSQURUFIAFQGEZLGZNOEQMNQEYUKPEQPPVAMO
+SYSFUAJFKIPUJVQSZRWQCJYAUMLDDNOKODDXIEQIFLANQIAOZFUNKUBVDBLMJOAUTVCZVLKJRQIORQPGAVCEYVNYUZHXILHERYEC
+GJEKWEKIJNIWUXZNVIWIAANHIOSOLATSQFSSCTAKESUTSPPYFHEHLVLIBJZEEBCOWMNHFTZMAPKFUPNFLTFFJQRVJHAKDVMGGUIX
+KAKXXNKSOAIQNALLWKWGVACYWBQEVTFSEUCYRORQTHWFUJFLQHONWZEKPLSNPRPBOMOFFCPMKXFZBKIERBKDYFKYUEYVYRPMOAQI
+WNICDLQKZXGTKDLIEFBGELGJOAIQNALXZLGGDQIBVEULDPBWUJNTYOKFBPGMAWRRUJPPIGYCNYURNOSQRIRBAZAGWWDUHAAZQWPT
+KFXZQXRMKSBUXWOUVVHSJWTLKZELGXMMAIDSJIWGCJPCBWZIEKMNUPUAFHTUMOZKJWVTIAQNOHELEMWGKJHKPNJVSRVHAUFXBUOU
+XOWCZJYQLXJRUOOYSKDLDXKWTTJBYBTLKSWRUYPOYTPBGUJXBMRWNELBWADCSZDAEEFGPVRHNNLBFDDXNPDXLKQUSJAZDEUDBMBD
+QIKYEKMVUHGGWZDKXFVQQNECZOAWCFUBHQMEPEPKEFSDBAYJQOSGAIHRBRAUKLQRANKMTTIOJDDXAEWTQHIYSGRRMEFTNNWCLZSI
+ZFUQAQCSFNVUQMKUQWBWFQIEQVVXPOSVIDTUOBLLTGHQKEMSUWWHWRISLGRDPPQPZBANSGDWXKNYTKMWECPMPDYSCJZXPUKPWGYI
+CNGVLBSCBHRLJARWSRENGHYYQDKRATERCPEAOPAJZUMOYIDHVPDMQPKKHCBAMRBGEIEXXJALMCXKPUGXYVINRORFYURXAMOJCBZQ
+YJHHAWESCLMDIHVYMLAJZQSYTDEURWYPOLJCAKIKSATGVIALBLWPPKDEGSPMRLDBQNVPPCLQXKUQLQJERMYFGAETUATEBQZUMGUN
+NBWUBVXYDFPLPJYLIDFVTVKKGFWMXVINLJUDUPABTSBJAJENZSXIMUJQWPEZTAVDMBBHFYTJKYFXIXQTBTTQIKQXQDPWYNMXRQDJ
+OGWLZQUBJJHAQNPVRGHGPNMMJPIDGANYEEDWYPOLKLNEPYSRTQYCJLSWFRJRRGGSNSDHIXYYSNAKKBWQDDGYYMOGPUXQEUSAPSOU
+CLLSELRVFZUFYVTJQKCQHNICMERWQFQNPVRPIIYKHZWJYJAFCLNSZXUHSPOZWQUMJHLKKYJENVZOCSWCTPYWIZONUUCLSUROGAYS
+AZGNIMXPLPCEPULRRBHHQOBELHJZPUQAMWUASVKDXVEWAOFMAYSJFXHCNEUXUQWUESFBRUFZQLKKWHCHKOPLECCBYSLECAEZIMMI
+TUUEOCEBAUKWLTSYJJPLZTIARAOZXKYYWIOXBBTZZCSAULKNEJWVQXIKUWBIWVHGNTHVBAWAVPGLHSDJDLPVHHHUNVSFKXARXLVQ
+EMVDFSLANQIAOPTLFLFRKGNUZCTXWCAXHECTZFHWUFENRGQICHTYLSHZWIEGLNVDJZOMTKAAUWOHVOVOCTUKOSINSAYIAEUYORNA
+VGPRMLCAQZIPRFQOZMEFTQZYVOTVFNVOIQSJCIPPQXQKJIXICUIGMHAJJMSXENCBQFIJHNZXIQMWACKDKQSEWWKMLOAUPFHAZGRY
+SQWQMRSQBGGKYKGWEZYRIHWGNXRPOUMFSFGTYDLUDWPWAVQORTMQUXWKUQVNMDPWQFIZPOIHCJATODRQGZDMQXZVNXXVEJNGWZOM
+PVBGZSQPCELDIWDHOQWAUHILGLPYRIICTLFSOYKQZYZOCIZPTECSWOODGGBDTSGIMYGMVPJPRPEVWOOKYFWRGXHWUCRQNYJEMSYL
+XWOFXFVDXPTHYTCEGMODCILAHYBREZVVHOUPZKCNHUEVPMKHUBNRPFMWXVQACVZCALZLYMZSBLCEASPMIEFOTGKMPGWYQADSNDPR
+QPHAVLZDZLKIEISFLLVWXAVBZLZIJRHGROUVGXRDLUJAXNHBBZYNCVERJGSKLWZEKGJBCWMSMLYIHZFFMIOGVIMZQBSRHQWAADYN
+MNXEGTDXCDKIUDOISQXEUJWETPELKBCYFSDNJQWNNBPYMWBUPQBAAINMYZOYCEGNLFNNHZFEMSQVXJJGWBCRAVKZFWFBKMBRVBFD
+HKACSZIUWUXLWKFPKOCUQJEPQDZCMUJFLVCLIOQQRVKSWFIAKNHMRLNJTKGVNTGLCVPVMBLJANOBCXUGVWBJYSIXZQVAVFWILWFB
+QWNLTPMCYHRSKVHXLONRANWKWXUTHYQLIOFKGDBMSWDRCYRKVSAGGRJMWQYQFLMUIGGCLAUQAACTYLPZEOJBHMWRKHCRXGTGRMUP
+CPQKJRBLYDNPUGHCRBVYBAIRVCAWLBWVWCMKNBIRKJOUGYQEBQRHDSTWXDIWGRVMLIJFBWHLHCDAAVUDLZSCGQNOUXVUIVIZZZMD
+NMHGYPFUUDWKQGTAKKGCDFJFYJFNRZVXDPGZEAMWQVQZODKTXHIYFVKJSSAWVHYCUCZMLLBPXTILDYJQEMWDRUFKISOUVPUDTYPB
+FDAQUBXHUJYTAYNWVIJNUSQDTQDEMUAPWXRYUWONTBDZCHZOUEGPMWEZTQWWSHAYOBWVTDIMZYNVNZKUHOFCQKPHJXWNRCGUJEKO
+WSDAUGUTVWCVHEMOIRJJGTANUWTSAIXXEVZTBDHPGSRHHVWCDZVZYRJTLONIJVXEATHQXOUKBIGZONFRSZIOGWNTYAJYLQCGEOWY
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/62.\347\205\244\347\220\203\346\225\260\347\233\256/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/62.\347\205\244\347\220\203\346\225\260\347\233\256/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b28f90a36b4807bb5034b528635ab62a98141c0e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/62.\347\205\244\347\220\203\346\225\260\347\233\256/solution.md"
@@ -0,0 +1,49 @@
+# 煤球数目
+
+有一堆煤球，堆成三角棱锥形。具体：  
+第一层放1个，  
+第二层3个（排列成三角形），  
+第三层6个（排列成三角形），  
+第四层10个（排列成三角形），  
+....  
+如果一共有100层，共有多少个煤球？  
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/64.\345\236\222\351\252\260\345\255\220/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/64.\345\236\222\351\252\260\345\255\220/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..31fc3bad8bea19f3cd62a4532cca954b7cc955f2
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/64.\345\236\222\351\252\260\345\255\220/solution.md"
@@ -0,0 +1,81 @@
+# 垒骰子
+
+赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。  
+经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！  
+我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。  
+假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。   
+atm想计算一下有多少种不同的可能的垒骰子方式。  
+两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。  
+由于方案数可能过多，请输出模 $10^9 + 7$ 的结果。  
+
+不要小看了 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
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/66.\351\227\250\347\211\214\345\210\266\344\275\234/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/66.\351\227\250\347\211\214\345\210\266\344\275\234/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..375fb35b17c345eb6610c6a919dad528e98eeaa1
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/66.\351\227\250\347\211\214\345\210\266\344\275\234/solution.md"
@@ -0,0 +1,47 @@
+# 门牌制作
+
+小蓝要为一条街的住户制作门牌号。  
+这条街一共有 2020 位住户，门牌号从 1 到 2020 编号。  
+小蓝制作门牌的方法是先制作 0 到 9 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、7，即需要 1 个字符 0，2 个字符 1，1 个字符 7。  
+请问要制作所有的 1 到 2020 号门牌，总共需要多少个字符 2？  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/68.\345\271\263\351\235\242\345\210\207\345\210\206/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/68.\345\271\263\351\235\242\345\210\207\345\210\206/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..40b34f149929771046bb8f6144ca2efe9304d017
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/68.\345\271\263\351\235\242\345\210\207\345\210\206/solution.md"
@@ -0,0 +1,66 @@
+# 平面切分
+
+#### 问题描述
+平面上有 N条直线，其中第 i条直线是$ y = A_i*x + B_i$。
+
+请计算这些直线将平面分成了几个部分。
+
+#### 输入格式
+第一行包含一个整数N。
+
+以下N行，每行包含两个整数 $A_i, B_i$。
+
+#### 输出格式
+一个整数代表答案。
+
+#### 样例输入
+```
+3
+1 1
+2 2
+3 3
+```
+#### 样例输出
+```
+6
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/7.\350\267\221\346\255\245\350\256\255\347\273\203/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/7.\350\267\221\346\255\245\350\256\255\347\273\203/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f2dd9dab9d6b9a1cc446bac8c716f23f9be81ccb
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/7.\350\267\221\346\255\245\350\256\255\347\273\203/solution.md"
@@ -0,0 +1,47 @@
+# 跑步训练
+
+小明要做一个跑步训练。  
+初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。    
+小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0 ，他就停止锻炼。  
+请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/70.\346\266\210\351\231\244\345\260\276\344\270\200/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/70.\346\266\210\351\231\244\345\260\276\344\270\200/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4f845325674ab13cb57857cbef824b06ef6fc404
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/70.\346\266\210\351\231\244\345\260\276\344\270\200/solution.md"
@@ -0,0 +1,60 @@
+# 消除尾一
+
+下面的代码把一个整数的二进制表示的最右边的连续的1全部变成0  
+如果最后一位是0，则原数字保持不变。  
+#### 输入：
+```
+00000000000000000000000001100111
+```
+#### 输出：
+```
+00000000000000000000000001100000
+```
+#### 输入：
+```
+00000000000000000000000000001100
+```
+#### 输出：
+```
+00000000000000000000000000001100
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/71.\345\233\233\345\271\263\346\226\271\345\222\214/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/71.\345\233\233\345\271\263\346\226\271\345\222\214/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b1b044ace117d4415ebbbd8f406eecdb11accfa8
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/71.\345\233\233\345\271\263\346\226\271\345\222\214/solution.md"
@@ -0,0 +1,87 @@
+# 四平方和
+
+四平方和定理，又称为拉格朗日定理：
+
+每个正整数都可以表示为至多4个正整数的平方和。  
+如果把0包括进去，就正好可以表示为4个数的平方和。  
+
+比如：
+```
+5 = 0^ 2 + 0^ 2 + 1^ 2 + 2^2
+7 = 1^ 2 + 1^ 2 + 1^ 2 + 2^2
+（^符号表示乘方的意思）
+```
+对于一个给定的正整数，可能存在多种平方和的表示法。  
+要求你对4个数排序：  
+```
+0 <= a <= b <= c <= d
+```
+并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法  
+
+程序输入为一个正整数N (N<5000000)  
+要求输出4个非负整数，按从小到大排序，中间用空格分开  
+
+例如，输入：
+```
+5
+```
+则程序应该输出：
+```
+0 0 1 2
+```
+再例如，输入：
+```
+12
+```
+则程序应该输出：
+```
+0 2 2 2
+```
+再例如，输入：
+```
+773535
+```
+则程序应该输出：
+```
+1 1 267 838
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/72.\345\205\260\351\241\277\350\232\202\350\232\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/72.\345\205\260\351\241\277\350\232\202\350\232\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..41cf1188d9b8dee289f6d40a31b9bdc3a418399c
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/72.\345\205\260\351\241\277\350\232\202\350\232\201/solution.md"
@@ -0,0 +1,89 @@
+# 兰顿蚂蚁
+
+问题描述  
+![](https://img-blog.csdnimg.cn/20200526100857208.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xsX3dhbmc=,size_16,color_FFFFFF,t_70)
+
+兰顿蚂蚁，是于1986年，由克里斯·兰顿提出来的，属于细胞自动机的一种。  
+平面上的正方形格子被填上黑色或白色。在其中一格正方形内有一只“蚂蚁”。  
+蚂蚁的头部朝向为：上下左右其中一方。    
+蚂蚁的移动规则十分简单：    
+若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；  
+若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。  
+
+规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。
+蚂蚁的路线是很难事先预测的。
+你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第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
+0 0 0 0 0 0
+0 0 1 0 0 0
+0 0 0 0 0 0
+0 0 0 0 0 0
+2 3 L 5
+```
+#### 样例输出
+```
+1 3
+```
+#### 样例输入
+```
+3 3
+0 0 0
+1 1 1
+1 1 1
+1 1 U 6
+```
+#### 样例输出
+```
+0 0
+```
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/73.\345\256\214\347\276\216\345\271\263\346\226\271\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/73.\345\256\214\347\276\216\345\271\263\346\226\271\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5f782166dca1ba47349f462fc545cb58400d73dd
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/73.\345\256\214\347\276\216\345\271\263\346\226\271\346\225\260/solution.md"
@@ -0,0 +1,47 @@
+# 完美平方数
+
+如果整个整数 X 本身是完全平方数，同时它的每一位数字也都是完全平方数，我们就称 X 是完美平方数。  
+前几个完美平方数是 0、1、4、9、49、100、144……  
+即第 1 个完美平方数是 0，第 2 个是 1，第 3 个是 4，……  
+请你计算第 2020 个完美平方数是多少？  
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/74.\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/74.\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d122a29ddd60d17f5f2f023edd8842fe4320bf93
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/74.\345\255\227\347\254\246\344\270\262\347\274\226\347\240\201/solution.md"
@@ -0,0 +1,74 @@
+# 字符串编码
+
+#### 问题描述
+小明发明了一种给由全大写字母组成的字符串编码的方法。  
+
+对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。
+
+这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。
+
+现在给定一个转换后的数字序列，小明想还原出原本的字符串。
+
+当然这样的还原有可能存在多个符合条件的字符串。
+
+小明希望找出其中字典序最大的字符串。
+
+#### 输入格式
+一个数字序列。
+
+#### 输出格式
+一个只包含大写字母的字符串，代表答案
+
+#### 样例输入
+```
+123242526
+```
+#### 样例输出
+```
+LCXYZ
+```
+#### 数据范围
+```
+对于 20% 的评测用例，输入的长度不超过 20。
+对于所有评测用例，输入的长度不超过 200000。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/75.\350\236\272\346\227\213\346\212\230\347\272\277/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/75.\350\236\272\346\227\213\346\212\230\347\272\277/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..231e259c40dafb79a25bf9381ec5da1154e2b41c
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/75.\350\236\272\346\227\213\346\212\230\347\272\277/solution.md"
@@ -0,0 +1,69 @@
+# 螺旋折线
+
+如图所示的螺旋折线经过平面上所有整点恰好一次。  
+对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。  
+
+例如```dis(0, 1)=3, dis(-2, -1)=9```
+
+给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？  
+
+#### 输入格式
+```
+X和Y
+
+对于40%的数据，-1000 <= X, Y <= 1000
+对于70%的数据，-100000 <= X， Y <= 100000
+对于100%的数据, -1000000000 <= X, Y <= 1000000000
+```
+#### 输出格式
+```
+输出dis(X, Y)
+```
+#### 样例输入
+```
+0 1
+```
+#### 样例输出
+```
+3
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/76.\350\200\220\346\221\224\346\214\207\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/76.\350\200\220\346\221\224\346\214\207\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1acaa412e094ee3d36e6231b4765cd32de08f028
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/76.\350\200\220\346\221\224\346\214\207\346\225\260/solution.md"
@@ -0,0 +1,85 @@
+# 耐摔指数
+
+x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
+各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
+
+x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
+
+如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
+特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
+如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
+
+为了减少测试次数，从每个厂家抽样3部手机参加测试。
+
+如果已知了测试塔的高度，并且采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
+
+输入数据，一个整数n（3<n<10000）,表示测试塔的高度。  
+输出一个整数，表示最多测试多少次。
+
+例如：
+输入：
+```
+3
+```
+程序应该输出：
+```
+2
+```
+解释：
+```
+手机a从2楼扔下去，坏了，就把b手机从1楼扔；否则a手机继续3层扔下
+```
+再例如：
+输入：
+```
+7
+```
+程序应该输出：
+```
+3
+```
+解释：
+```
+a手机从4层扔，坏了，则下面有3层，b,c 两部手机2次足可以测出指数；
+若是没坏，手机充足，上面5,6,7 三层2次也容易测出。
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/78.\345\257\206\347\240\201\350\204\261\350\220\275/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/78.\345\257\206\347\240\201\350\204\261\350\220\275/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..170a8a4f89b90a1276bfaef53efe7322c3030fd5
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/78.\345\257\206\347\240\201\350\204\261\350\220\275/solution.md"
@@ -0,0 +1,69 @@
+# 密码脱落
+
+X星球的考古学家发现了一批古代留下来的密码。  
+这些密码是由A、B、C、D 四种植物的种子串成的序列。  
+仔细分析发现，这些密码串当初应该是前后对称的（也就是我们说的镜像串）。  
+由于年代久远，其中许多种子脱落了，因而可能会失去镜像的特征。  
+
+你的任务是：  
+给定一个现在看到的密码串，计算一下从当初的状态，它要至少脱落多少个种子，才可能会变成现在的样子。
+
+输入一行，表示现在看到的密码串（长度不大于1000）  
+要求输出一个正整数，表示至少脱落了多少个种子。  
+
+例如，输入：
+```
+ABCBA
+```  
+则程序应该输出：  
+```
+0
+```
+再例如，输入：
+```
+ABDCDCBABC
+```
+则程序应该输出：
+```
+3
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/79.\345\255\227\346\257\215\347\273\204\344\270\262/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/79.\345\255\227\346\257\215\347\273\204\344\270\262/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..deb9a72c175140d7b06d80440850bd3b066995a8
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/79.\345\255\227\346\257\215\347\273\204\344\270\262/solution.md"
@@ -0,0 +1,46 @@
+# 字母组串
+
+由A , B , C A,B,CA,B,C这3个字母就可以组成许多串。  
+
+比如："A AA"，"A B ABAB"，"A B C ABCABC"，"A B A ABAABA"，"A A C B B AACBBAACBB"……现在，小明正在思考一个问题：如果每个字母的个数有限定，能组成多少个已知长度的串呢？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/8.\345\217\226\346\225\260\344\275\215/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/8.\345\217\226\346\225\260\344\275\215/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3a52e4752dca8d5f0c3cf6cf4e6e4c97bc15e5b1
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/8.\345\217\226\346\225\260\344\275\215/solution.md"
@@ -0,0 +1,47 @@
+# 取数位
+
+求1个整数的第k位数字有很多种方法。
+
+以下的方法就是一种。
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/80.\347\201\276\345\220\216\351\207\215\345\273\272/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/80.\347\201\276\345\220\216\351\207\215\345\273\272/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c1d01e6a954abab6b9011cb573639fec05e21cb6
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/80.\347\201\276\345\220\216\351\207\215\345\273\272/solution.md"
@@ -0,0 +1,87 @@
+# 灾后重建
+
+#### 问题描述：
+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
+2 6 9
+4 1 5
+3 7 4
+3 6 9
+1 5 8
+2 7 4
+3 2 10
+1 7 6
+7 6 9
+1 7 1 0
+1 7 3 1
+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)范围内。
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/81.\351\224\246\346\240\207\350\265\233/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/81.\351\224\246\346\240\207\350\265\233/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7b66dddd8c3f04fd89a606d4262a92a7f598fb37
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/81.\351\224\246\346\240\207\350\265\233/solution.md"
@@ -0,0 +1,56 @@
+# 锦标赛
+
+如果要在n个数据中挑选出第一大和第二大的数据（要求输出数据所在位置和值），使用什么方法比较的次数最少？我们可以从体育锦标赛中受到启发。
+
+如图所示，8个选手的锦标赛，先两两捉对比拼，淘汰一半。优胜者再两两比拼...直到决出第一名。
+
+第一名输出后，只要对黄色标示的位置重新比赛即可。
+
+![](https://img-blog.csdn.net/20180325224626876)
+
+下面的代码实现了这个算法（假设数据中没有相同值）。
+
+代码中需要用一个数组来表示图中的树（注意，这是个满二叉树，不足需要补齐）。它不是存储数据本身，而是存储了数据的下标。
+
+第一个数据输出后，它所在的位置被标识为-1
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/82.\345\257\273\346\211\2762020/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/82.\345\257\273\346\211\2762020/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..872ce615c48e3c230f4bb19568bfe46a17a29ebf
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/82.\345\257\273\346\211\2762020/solution.md"
@@ -0,0 +1,64 @@
+# 寻找2020
+
+小蓝有一个数字矩阵，里面只包含数字 0 和 2。小蓝很喜欢 2020，他想找到这个数字矩阵中有多少个 2020 。
+
+小蓝只关注三种构成 2020 的方式：
+* 同一行里面连续四个字符从左到右构成 2020。
+* 同一列里面连续四个字符从上到下构成 2020。
+* 在一条从左上到右下的斜线上连续四个字符，从左上到右下构成 2020。
+
+例如，对于下面的矩阵：
+```
+220000
+000000
+002202
+000000
+000022
+002020
+```
+一共有 5 个 2020。其中 1 个是在同一行里的，1 个是在同一列里的，3 个是斜线上的。  
+小蓝的矩阵比上面的矩阵要大，由于太大了，他只好将这个矩阵放在了一个文件里面，在试题目录下有一个文件 2020.txt，里面给出了小蓝的矩阵。  
+请帮助小蓝确定在他的矩阵中有多少个 2020。
+
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/83.BST \346\217\222\345\205\245\350\212\202\347\202\271\351\227\256\351\242\230/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/83.BST \346\217\222\345\205\245\350\212\202\347\202\271\351\227\256\351\242\230/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..93c219b32840840f30a5e454e8613c3d329df09e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/83.BST \346\217\222\345\205\245\350\212\202\347\202\271\351\227\256\351\242\230/solution.md"	
@@ -0,0 +1,78 @@
+# BST 插入节点问题
+
+#### 问题描述
+给定一棵包含 N 个节点的二叉树，节点编号是 1 ∼ N。其中 i 号节点具有权值 W i ，并且这些节点的权值恰好形成了一棵排序二叉树 (BST)。  
+现在给定一个节点编号 K，小明想知道，在这 N 个权值以外，有多少个整数 X (即 X 不等于任何 W i ) 满足：给编号为 K 的节点增加一个权值为 X 的子节点，仍可以得到一棵 BST。  
+例如在下图中，括号外的数字表示编号、括号内的数字表示权值。即编号1 ∼ 4 的节点权值依次是 0、10、20、30。
+
+![](https://img-blog.csdnimg.cn/20201010210318917.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbGtMZW9uZw==,size_16,color_FFFFFF,t_70#pic_center)
+
+如果 K = 1，那么答案为 0。因为 1 号节点已经有左右子节点，不能再增加子节点了。  
+如果 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
+1 0
+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 各不相同。
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/84.\345\234\206\345\221\250\347\216\207/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/84.\345\234\206\345\221\250\347\216\207/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3701c6d2cf4c27e7744e1a52c1d8fe3b71f3c685
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/84.\345\234\206\345\221\250\347\216\207/solution.md"
@@ -0,0 +1,52 @@
+# 圆周率
+
+数学发展历史上，圆周率的计算曾有许多有趣甚至是传奇的故事。其中许多方法都涉及无穷级数。
+
+图中所示，就是一种用连分数的形式表示的圆周率求法。
+
+![](https://img-blog.csdnimg.cn/20210128181357213.png)
+
+
+下面的程序实现了该求解方法。实际上数列的收敛对x的初始值 并不敏感。 
+
+结果打印出圆周率近似值（保留小数点后4位，并不一定与圆周率真值吻合）。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/85.\345\205\255\350\247\222\345\241\253\346\225\260/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/85.\345\205\255\350\247\222\345\241\253\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..aee1ee908888ad7e324f110dc9acf2221b9f1706
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/85.\345\205\255\350\247\222\345\241\253\346\225\260/solution.md"
@@ -0,0 +1,46 @@
+# 六角填数
+
+如图所示六角形中，填入1~12的数字。  
+使得每条直线上的数字之和都相同。  
+图中，已经替你填好了3个数字，请你计算星号位置所代表的数字是多少？  
+![](https://img-blog.csdn.net/20160124154420856)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/86.\346\255\243\345\210\231\351\227\256\351\242\230/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/86.\346\255\243\345\210\231\351\227\256\351\242\230/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4035bfccdc9dc6b9b910e568902d12d2ec335b89
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/86.\346\255\243\345\210\231\351\227\256\351\242\230/solution.md"
@@ -0,0 +1,58 @@
+# 正则问题
+
+#### 问题描述：
+考虑一种简单的正则表达式：只由```x()|```组成的正则表达式。  
+小明想求出这个正则表达式能接受的最长字符串的长度。  
+例如```((xx|xxx)x|(x|xx))xx``` 能接受的最长字符串是： ```xxxxxx```，长度是6。
+#### 输入格式：
+一个由```x()|```组成的正则表达式。输入长度不超过100，保证合法。
+#### 输出格式：
+这个正则表达式能接受的最长字符串的长度。
+#### 样例输入：
+```
+((xx|xxx)x|(x|xx))xx
+```
+样例输出：
+```
+6
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/87.\347\253\213\346\226\271\345\217\230\350\207\252\350\272\253/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/87.\347\253\213\346\226\271\345\217\230\350\207\252\350\272\253/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..30e28791d93503ec7eec3757975eeccbb8ff1149
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/87.\347\253\213\346\226\271\345\217\230\350\207\252\350\272\253/solution.md"
@@ -0,0 +1,50 @@
+# 立方变自身
+
+观察下面的现象,某个数字的立方，按位累加仍然等于自身。 
+```
+1^3 = 1
+8^3 = 512 5+1+2=8 
+17^3 = 4913 4+9+1+3=17 
+…
+```
+请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/89.\345\217\226\347\220\203\346\270\270\346\210\217/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/89.\345\217\226\347\220\203\346\270\270\346\210\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3ba2232901fcac0c7d139e89265a72615b3beaac
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/89.\345\217\226\347\220\203\346\270\270\346\210\217/solution.md"
@@ -0,0 +1,72 @@
+# 取球游戏
+
+今盒子里有n个小球，A、B两人轮流从盒中取球，每个人都可以看到另一个人取了多少个，也可以看到盒中还剩下多少个，并且两人都很聪明，不会做出错误的判断。  
+
+我们约定：  
+每个人从盒子中取出的球的数目必须是：1，3，7或者8个。轮到某一方取球时不能弃权！  
+A先取球，然后双方交替取球，直到取完。  
+被迫拿到最后一个球的一方为负方（输方）  
+
+请编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？
+
+程序运行时，从标准输入获得数据，其格式如下：
+
+先是一个整数n(n<100)，表示接下来有n个整数。然后是n个整数，每个占一行（整数<10000），表示初始球数。
+
+程序则输出n行，表示A的输赢情况（输为0，赢为1）。
+
+例如，用户输入：
+```
+4
+1
+2
+10
+18
+```
+则程序应该输出：
+```
+0
+1
+1
+0
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/9.\350\267\221\346\255\245\351\224\273\347\202\274/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/9.\350\267\221\346\255\245\351\224\273\347\202\274/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e8f04c78f3e8263605e956952c80e5861542cb08
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/9.\350\267\221\346\255\245\351\224\273\347\202\274/solution.md"
@@ -0,0 +1,45 @@
+# 跑步锻炼
+
+小蓝每天都锻炼身体。  
+正常情况下，小蓝每天跑1千米。如果某天是周一或者月初（1日），为了激励自己，小蓝要跑2千米。如果同时是周一或月初，小蓝也是跑2千米。  
+小蓝跑步已经坚持了很长时间，从2000年1月1日周六（含）到2020年10月1日周四（含）。请问这段时间小蓝总共跑步多少千米？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/90.\345\271\263\346\226\271\345\222\214/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/90.\345\271\263\346\226\271\345\222\214/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..590877275741e8dc184b0ba63be153ce8c03bc0e
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/90.\345\271\263\346\226\271\345\222\214/solution.md"
@@ -0,0 +1,45 @@
+# 平方和
+
+小明对数位中含有 2、0、1、9 的数字很感兴趣，在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574，平方和是 14362。注意，平方和是指将每个数分别平方后求和。  
+请问，在 1 到 2019 中，所有这样的数的平方和是多少？
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/93.\350\210\252\347\217\255\346\227\266\351\227\264/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/93.\350\210\252\347\217\255\346\227\266\351\227\264/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e78f1ed7bc8666a4a1660ec7523cd644fd859834
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/93.\350\210\252\347\217\255\346\227\266\351\227\264/solution.md"
@@ -0,0 +1,120 @@
+# 航班时间
+
+#### 问题背景
+
+小h前往美国参加了蓝桥杯国际赛。小h的女朋友发现小h上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。
+
+小h对超音速飞行感到十分恐惧。仔细观察后发现飞机的起降时间都是当地时间。由于北京和美国东部有12小时时差，故飞机总共需要14小时的飞行时间。
+
+不久后小h的女朋友去中东交换。小h并不知道中东与北京的时差。但是小h得到了女朋友来回航班的起降时间。小h想知道女朋友的航班飞行时间是多少。
+
+#### 问题描述
+
+对于一个可能跨时区的航班，给定来回程的起降时间。假设飞机来回飞行时间相同，求飞机的飞行时间。
+
+#### 输入格式
+
+从标准输入读入数据。
+
+一个输入包含多组数据。
+
+输入第一行为一个正整数T，表示输入数据组数。
+
+每组数据包含两行，第一行为去程的 起降 时间，第二行为回程的 起降 时间。
+
+起降时间的格式如下：
+```
+h1:m1:s1 h2:m2:s2 或 h1:m1:s1 h3:m3:s3 (+1) 或 h1:m1:s1 h4:m4:s4 (+2)
+```
+表示该航班在当地时间h1时m1分s1秒起飞，
+
+第一种格式表示在当地时间 当日 h2时m2分s2秒降落
+
+第二种格式表示在当地时间 次日 h3时m3分s3秒降落。
+
+第三种格式表示在当地时间 第三天 h4时m4分s4秒降落。
+
+对于此题目中的所有以 h:m:s 形式给出的时间, 保证 ( 0<=h<=23, 0<=m,s<=59 ).
+
+#### 输出格式
+
+输出到标准输出。
+
+对于每一组数据输出一行一个时间hh:mm:ss，表示飞行时间为hh小时mm分ss秒。
+
+注意，当时间为一位数时，要补齐前导零。如三小时四分五秒应写为03:04:05。
+
+#### 样例输入
+```
+3
+
+17:48:19 21:57:24
+
+11:05:18 15:14:23
+
+17:21:07 00:31:46 (+1)
+
+23:02:41 16:13:20 (+1)
+
+10:19:19 20:41:24
+
+22:19:04 16:41:09 (+1)
+```
+#### 样例输出
+```
+04:09:05
+
+12:10:39
+
+14:22:05
+```
+#### 限制与约定
+
+保证输入时间合法，飞行时间不超过24小时。
+
+#### 资源约定：
+
+峰值内存消耗（含虚拟机）< 256M
+
+CPU消耗 < 1000ms
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/94.\346\225\260\347\232\204\345\210\206\350\247\243/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/94.\346\225\260\347\232\204\345\210\206\350\247\243/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..64b9dd2cda3d22ca8feaf16b4b17c2fe16418e88
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/94.\346\225\260\347\232\204\345\210\206\350\247\243/solution.md"
@@ -0,0 +1,45 @@
+# 数的分解
+
+把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包含数字 2 和 4，一共有多少种不同的分解方法？
+
+注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/95.\351\255\224\346\226\271\347\212\266\346\200\201/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/95.\351\255\224\346\226\271\347\212\266\346\200\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7c5f2df95f0b74c907871b70a04d44dd55ab0e1c
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/95.\351\255\224\346\226\271\347\212\266\346\200\201/solution.md"
@@ -0,0 +1,62 @@
+# 魔方状态
+
+二阶魔方就是只有2层的魔方，只由8个小块组成。
+
+小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
+```
+前面：橙色
+
+右面：绿色
+
+上面：黄色
+
+左面：绿色
+
+下面：橙色
+
+后面：黄色
+```
+请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态？  
+如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
+
+![](https://img-blog.csdnimg.cn/20201110192355364.png#pic_center)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```
diff --git "a/data_backup/3.\350\223\235\346\241\245\346\235\257/96.\345\271\263\351\235\242\345\210\206\345\211\262/solution.md" "b/data_backup/3.\350\223\235\346\241\245\346\235\257/96.\345\271\263\351\235\242\345\210\206\345\211\262/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..beba63c1de84a2cf232835ee40f56e6dfa5efce4
--- /dev/null
+++ "b/data_backup/3.\350\223\235\346\241\245\346\235\257/96.\345\271\263\351\235\242\345\210\206\345\211\262/solution.md"
@@ -0,0 +1,43 @@
+# 平面分割
+
+20个圆和20条直线最多能把平面分成多少个部分?
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+
+```
+
+## 选项
+
+### A
+
+```cpp
+
+```
+
+### B
+
+```cpp
+
+```
+
+### C
+
+```cpp
+
+```