diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..91ded9353ac0e8c1b347cb777b03735105b8538c
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-7155bf0956dc4133abb9ba64b5e4f6ae",
+  "keywords": [
+    "蓝桥杯",
+    "星系炸弹"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2dddddb90059344955d35635f05f9d0e43e3a792
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/desc.md"
@@ -0,0 +1,4 @@
+在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。  
+每个炸弹都可以设定多少天之后爆炸。  
+比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。  
+有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。  
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..d7914426509f68c7ccc9dba151cc774d4bda327f
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.cpp"
@@ -0,0 +1,32 @@
+#include <cstdio>
+int month[13][2] = {{0, 0}, {31, 31}, {28, 29}, {31, 31}, {30, 30}, {31, 31}, {30, 30}, {31, 31}, {31, 31}, {30, 30}, {31, 31}, {30, 30}, {31, 31}};
+
+bool isLeap(int year)
+{
+    return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
+}
+
+int main()
+{
+    int y, m, d;
+    int count;
+    scanf("%d-%d-%d", &y, &m, &d);
+    scanf("%d", &count);
+    while (count)
+    {
+        d++;
+        if (d > month[m][isLeap(y)])
+        {
+            d = 1;
+            m++;
+        }
+        if (m > 12)
+        {
+            m = 1;
+            y++;
+        }
+        count--;
+    }
+    printf("%d-%d-%d", y, m, d);
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..fe0d268c3608e0fc6f7a019fc44eb745b8c6599f
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "880abd1a201c4b02b1c3e75a502c8fcc"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\346\230\237\347\263\273\347\202\270\345\274\271/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ad7f1779968ea70f28a78c47c61612644bd368cc
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/20.\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
+2017-08-05
+```
+
+## 选项
+
+### A
+
+```cpp
+2017-09-05
+```
+
+### B
+
+```cpp
+2017-08-06
+```
+
+### C
+
+```cpp
+2017-09-06
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..14aa1adbd1339b4785da1bc26e41af908fb3c088
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-f4874378183445fb9edcf1cb372399f7",
+  "keywords": [
+    "蓝桥杯",
+    "蛇形填数"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..bc504b70389c9f8d66a1432952cce379ec433eb2
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/desc.md"
@@ -0,0 +1,3 @@
+如下图所示，小明用从1 开始的正整数“蛇形”填充无限大的矩阵。  
+![](https://img-blog.csdnimg.cn/20210221154521571.png)  
+容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20 行第20 列的数是多少？
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..0659026b91f7413ee44afb86a0286b933be5214e
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.cpp"
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <math.h>
+
+int main()
+{
+    int map[50][50];
+    int i, j, cnt = 1;
+    int nowi, nowj;
+    for (i = 1; i <= 40; i++)
+    {
+        if (i & 1)
+        { //若为奇数轮的时候,是从左下角到右上角
+            nowi = i, nowj = 1;
+            for (j = 0; j < i; j++)
+                map[nowi - j][nowj + j] = cnt++;
+        }
+        else
+        { //若为偶数轮的时候,是从右上角到左下角
+            nowi = 1, nowj = i;
+            for (j = 0; j < i; j++)
+                map[nowi + j][nowj - j] = cnt++;
+        }
+    }
+    printf("%d", map[20][20]); //答案:761
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..babb0f5ffbd0113460a15320c5dce7868db54238
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "383bda00ddc5462ab99e42db64e0f076"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\350\233\207\345\275\242\345\241\253\346\225\260/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8641aaa2163f0afe8f03e353b41ab924ec231aa2
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/21.\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
+761
+```
+
+## 选项
+
+### A
+
+```cpp
+759
+```
+
+### B
+
+```cpp
+760
+```
+
+### C
+
+```cpp
+769
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..485643bee058f398a2edf4a05520ec26247132ef
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-e707e31088ea4929964936a8f8ef15d7",
+  "keywords": [
+    "蓝桥杯",
+    "跑步训练"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9a69aa3f4c61704b1b33601edc04e2414d9508a5
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/desc.md"
@@ -0,0 +1,4 @@
+小明要做一个跑步训练。  
+初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。    
+小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0 ，他就停止锻炼。  
+请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..06f13676192c5cf1e11351a745b03c549b1bcfdb
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.cpp"
@@ -0,0 +1,44 @@
+#include <iostream>
+using namespace std;
+
+int slove(int n)
+{
+    int m = 0;
+    while (true)
+    {
+        // 体力大于600，还能进行下次循环
+        if (n > 600)
+        {
+            n -= 600; //      跑1分钟消耗600体力
+        }
+        else
+        {
+            // 600/60 每秒钟消耗的体力
+            // n / (600 / 60)  n体力能够跑的时间
+            return m + n / (600 / 60);
+        }
+
+        n += 300;       //      休息1分钟提升300体力
+        m = m + 2 * 60; //      一个循环2分钟
+    }
+}
+
+// 递归算法
+int slove_d(int n)
+{
+    //体力不大于600，结束递归
+    if (n <= 600)
+    {
+        return n / (600 / 60);
+    }
+
+    // 每次循环2分钟， 消耗300体力
+    return 60 * 2 + slove_d(n - 300);
+}
+
+int main()
+{
+    cout << slove(10000) << endl;
+    cout << slove_d(10000) << endl;
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..03cd90f6c8fa690d7025ffe1d11c408fa97289b5
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "916f0cb3ec744b6a94784acd8f421495"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\350\267\221\346\255\245\350\256\255\347\273\203/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1e06357006ffc4a46538ad09865bc2e1fb4cf691
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/22.\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
+3880
+```
+
+## 选项
+
+### A
+
+```cpp
+3400
+```
+
+### B
+
+```cpp
+3920
+```
+
+### C
+
+```cpp
+3900
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..700aaca40244cb21fca4cb1368c890281fffba4c
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-ef2760aef95742c49f78c313d1ff2eb1",
+  "keywords": [
+    "蓝桥杯",
+    "特别数的和"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c0b7aee131c629cb44b6dfee947fbb33bd7e3dbc
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/desc.md"
@@ -0,0 +1,23 @@
+#### 题目描述
+小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
+
+请问，在 1 到 n 中，所有这样的数的和是多少？
+
+#### 输入格式
+共一行，包含一个整数 n。
+
+#### 输出格式
+共一行，包含一个整数，表示满足条件的数的和。
+
+#### 数据范围
+```
+1≤n≤10000
+```
+#### 输入样例：
+```
+40
+```
+#### 输出样例：
+```
+574
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..513a18061b257abc3b09bccec0d3aff5357fe8b3
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.cpp"
@@ -0,0 +1,32 @@
+#include <iostream>
+
+using namespace std;
+
+int ans, n;
+
+bool check(int n)
+{
+    while (n)
+    {
+        int tmpn = n % 10;
+        if (tmpn == 2 || tmpn == 0 || tmpn == 1 || tmpn == 9)
+            return true;
+        n /= 10;
+    }
+    return false;
+}
+
+int main()
+{
+    cin >> n;
+
+    for (int i = 1; i <= n; i++)
+    {
+        if (check(i))
+            ans += i;
+    }
+
+    cout << ans << endl;
+
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..faf4ae7d79ccdd6bdf0f531e262ad6ae19254c10
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "17de9b97dbc247aba50ec0c5c0170a68"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c6969e72d8075798160baf9669967e2f4f9764f0
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/23.\347\211\271\345\210\253\346\225\260\347\232\204\345\222\214/solution.md"
@@ -0,0 +1,111 @@
+# 特别数的和
+
+**题目描述**
+
+小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
+
+请问，在 1 到 n 中，所有这样的数的和是多少？
+
+**输入格式**
+
+共一行，包含一个整数 n。
+
+**输出格式**
+
+共一行，包含一个整数，表示满足条件的数的和。
+
+**数据范围**
+
+```
+1≤n≤10000
+```
+
+**输入样例：**
+
+```
+40
+```
+
+**输出样例：**
+
+```
+574
+```
+
+以下代码实现了这一功能，请你填补空白处的内容：
+
+```cpp
+#include <iostream>
+
+using namespace std;
+
+int ans, n;
+
+bool check(int n)
+{
+    while (n)
+    {
+        int tmpn = n % 10;
+        if (tmpn == 2 || tmpn == 0 || tmpn == 1 || tmpn == 9)
+            return true;
+        __________________
+    }
+    return false;
+}
+
+int main()
+{
+    cin >> n;
+
+    for (int i = 1; i <= n; i++)
+    {
+        if (check(i))
+            ans += i;
+    }
+
+    cout << ans << endl;
+
+    return 0;
+}
+```
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+        n /= 10;
+```
+
+## 选项
+
+### A
+
+```cpp
+        n %= 10;
+```
+
+### B
+
+```cpp
+        break;
+```
+
+### C
+
+```cpp
+        continue;
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..9339e29b49dc962ccede2bef166372f51324db78
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-530255df51be437b967cbc4524fe66ea",
+  "keywords": [
+    "蓝桥杯",
+    "切面条"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ba37a1d8bab07427d9ed1c61382134d84e876d76
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/desc.md"
@@ -0,0 +1,4 @@
+一根高筋拉面，中间切一刀，可以得到2根面条。  
+如果先对折1次，中间切一刀，可以得到3根面条。  
+如果连续对折2次，中间切一刀，可以得到5根面条。  
+那么，连续对折10次，中间切一刀，会得到多少面条呢？      
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..d034f00ce70516785e6000772a0d33acbddd3da2
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.cpp"
@@ -0,0 +1,12 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    int f[10];
+    f[1] = 3;
+    for (int i = 2; i < 11; i++)
+        f[i] = f[i - 1] * 2 - 1; //等同(f[i-1]-1)*2+1
+    cout << f[10];
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..76562a8d324c536b13b6dfafc071f3ac920232be
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "096fc08eabd34865aa1a97820435d66b"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\345\210\207\351\235\242\346\235\241/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..047e6d57f56c6a4089f4ab032ee09ebde5b8436a
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/24.\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
+1025
+```
+
+## 选项
+
+### A
+
+```cpp
+1024
+```
+
+### B
+
+```cpp
+512
+```
+
+### C
+
+```cpp
+513
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..2f4286cb61ef240d4fe0a1f582495dcc383ba740
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-9aea8ae61f274180b9b7172c43ebe69f",
+  "keywords": [
+    "蓝桥杯",
+    "日志统计"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..9e13a8690e5653bbdd4f1058517a107a17b8b968
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/desc.md"
@@ -0,0 +1,47 @@
+#### 题目描述
+小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 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
+```
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..878d84d2a36d0fdd93a441b568a7c2e2ceb496b0
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.cpp"
@@ -0,0 +1,35 @@
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+const int N = 1e5 + 10;
+typedef pair<int, int> PII;
+#define x first
+#define y second
+PII logs[N];
+bool st[N];
+int cnt[N];
+
+int main()
+{
+    int n, d, k;
+    cin >> n >> d >> k;
+    for (int i = 0; i < n; i++)
+        cin >> logs[i].x >> logs[i].y; //时间，编号
+
+    sort(logs, logs + n); //按照时间先排序
+
+    for (int i = 0, j = 0; i < n; i++)
+    {
+        cnt[logs[i].y]++; //目标编号出现次数加1
+        while (logs[i].x - logs[j].x >= d)
+            cnt[logs[j].y]--, j++; //滑动窗口，保证目标区域合法
+        if (cnt[logs[i].y] >= k)
+            st[logs[i].y] = true; //如果编号次数超K则输出
+    }
+
+    for (int i = 0; i < N; i++)
+        if (st[i])
+            cout << i << endl;
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d3432cb89e569709ae6ea00b91454025cd9cceb6
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "55585dfb13104063adb7e4d41384f5a6"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..4acf360a284ea7b8055a0b739769978b648128fd
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/25.\346\227\245\345\277\227\347\273\237\350\256\241/solution.md"
@@ -0,0 +1,136 @@
+# 日志统计
+
+**题目描述**
+
+小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 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
+```
+
+下面的程序实现了这一功能，请你补全空白处的内容：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+const int N = 1e5 + 10;
+typedef pair<int, int> PII;
+#define x first
+#define y second
+PII logs[N];
+bool st[N];
+int cnt[N];
+
+int main()
+{
+    int n, d, k;
+    cin >> n >> d >> k;
+    for (int i = 0; i < n; i++)
+        cin >> logs[i].x >> logs[i].y;
+
+    sort(logs, logs + n);
+
+    for (int i = 0, j = 0; i < n; i++)
+    {
+        cnt[logs[i].y]++;
+        while (logs[i].x - logs[j].x >= d)
+            __________________
+        if (cnt[logs[i].y] >= k)
+            st[logs[i].y] = true;
+    }
+
+    for (int i = 0; i < N; i++)
+        if (st[i])
+            cout << i << endl;
+    return 0;
+}
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+cnt[logs[j].y]--, j++;
+```
+
+## 选项
+
+### A
+
+```cpp
+cnt[logs[j].y]--; j++;
+```
+
+### B
+
+```cpp
+cnt[logs[j].y]++, j++;
+```
+
+### C
+
+```cpp
+cnt[logs[j].y]++; j++;
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..72efb4a66c9fad21c5e25b7ed7bce8ad57bf18ed
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-d98c791357f2416389a36896d0186317",
+  "keywords": [
+    "蓝桥杯",
+    "神奇算式"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3055ccecbad8e8fafb7f5277c2372c4c1b342f86
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/desc.md"
@@ -0,0 +1,9 @@
+由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。
+比如： 
+```
+210 x 6 = 1260 
+8 x 473 = 3784
+27 x 81 = 2187 
+```
+都符合要求。  
+如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..e1f1ba34972c17eb80ae73d4f916b4a7b0068b33
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.cpp"
@@ -0,0 +1,106 @@
+#include <iostream>
+#define MAX_N 1005
+using namespace std;
+
+bool judge1(int n) //判断两个数的乘积是否为4位数
+{
+    int ans = 0;
+    while (n)
+    {
+        ans++;
+        n /= 10;
+    }
+    if (ans == 4)
+        return true;
+    return false;
+}
+
+bool judge2(int i, int j) //判断乘积的数是否为原来的四个数
+{
+    int s1 = 0, s2 = 0;   //和
+    int ss1 = 1, ss2 = 1; //积
+    int tmp = i * j;
+    bool flag1 = true, flag2 = true;
+    while (tmp)
+    {
+        s1 += tmp % 10;
+        if (tmp % 10 == 0)
+            flag1 = false;
+        else
+            ss1 *= tmp % 10;
+        tmp /= 10;
+    }
+    while (j)
+    {
+        s2 += j % 10;
+        if (j % 10 != 0)
+            ss2 *= j % 10;
+        else
+            flag2 = false;
+        j /= 10;
+    }
+    while (i)
+    {
+        s2 += i % 10;
+        if (i % 10 != 0)
+            ss2 *= i % 10;
+        else
+            flag2 = false;
+        i /= 10;
+    }
+    if (s1 == s2 && ss1 == ss2 && flag1 && flag2) //如果没有0的话，是否乘积和和都相等
+        return true;
+    else if ((!flag1 && !flag2) && s1 == s2 && ss1 == ss2) //如果有0的话，是否乘积都相等
+        return true;
+    return false;
+}
+
+bool judge3(int i, int j) //判断两个数中是否全是不同的数
+{
+    int a[4];
+    int ans = 0;
+    while (i)
+    {
+        a[ans] = i % 10;
+        i /= 10;
+        ans++;
+    }
+    while (j)
+    {
+        a[ans] = j % 10;
+        j /= 10;
+        ans++;
+    }
+    for (i = 0; i < 3; i++)
+    {
+        for (j = i + 1; j < 4; j++)
+            if (a[i] == a[j]) //如果有相等的话返回false
+                return false;
+    }
+    return true;
+}
+
+int main()
+{
+    //freopen("data.txt","r",stdin);
+    int i, j;
+    int ans = 0;
+    for (i = 1; i < 10; i++)
+    { //一位数乘以三位数
+        for (j = 123; j < 1000; j++)
+        {
+            if (judge1(i * j) && judge2(i, j) && judge3(i, j))
+                ans++;
+        }
+    }
+    for (i = 10; i < 100; i++)
+    { //两位数乘以两位数
+        for (j = i + 1; j < 100; j++)
+        {
+            if (judge1(i * j) && judge2(i, j) && judge3(i, j))
+                ans++;
+        }
+    }
+    cout << ans;
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..3565802eb81142c615fbef1ba30e208f7eb28e93
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "aad0e280f4944ea9aff2b9e426aaef21"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..81d69dc937ebc13e9cfdae6d7063d381b98145c9
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/26.\347\245\236\345\245\207\347\256\227\345\274\217/solution.md"
@@ -0,0 +1,295 @@
+# 神奇算式
+
+由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。
+比如： 
+```
+210 x 6 = 1260 
+8 x 473 = 3784
+27 x 81 = 2187 
+```
+都符合要求。  
+如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。
+
+以下选项错误的是？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+int vis[10];
+int ans = 0;
+bool s(int i)
+{
+    while (i)
+    {
+        if (vis[i % 10] == 1)
+            return false;
+        else
+        {
+            vis[i % 10] = 1;
+            i /= 10;
+        }
+    }
+    return true;
+}
+int main()
+{
+    for (int i = 1; i < 999; i++)
+    {
+        for (int j = 1; j < 999; j++)
+        {
+            memset(vis, 0, sizeof(vis));
+            if (s(i) && s(j))
+            {
+                int k = i * j;
+                if (k > 9999 || k < 1000)
+                    continue;
+
+                int t = k;
+                while (k)
+                {
+                    if (vis[k % 10] == 1)
+                    {
+                        vis[k % 10]++;
+
+                        k /= 10;
+                    }
+                    else
+                        break;
+                }
+                if (k == 0 && vis[0] != 1 && vis[1] != 1 && vis[2] != 1 && vis[3] != 1 && vis[4] != 1 && vis[5] != 1 && vis[6] != 1 && vis[7] != 1 && vis[8] != 1 && vis[9] != 1)
+                {
+                    ans++;
+                }
+            }
+        }
+    }
+    cout << ans << endl;
+    return 0;
+}
+```
+
+## 选项
+
+### A
+
+```cpp
+bool isOk(int result, int t1, int t2)
+{
+    bool flag1[10] = {0}, flag2[10] = {0};
+    int i, rNum[4], num[4];
+    for (i = 0; i < 4; i++)
+    {
+        rNum[i] = result % 10;
+        result /= 10;
+        if (flag1[rNum[i]])
+            return false;
+        flag1[rNum[i]] = true;
+    }
+    i = 0;
+    while (t1 > 0)
+    {
+        num[i] = t1 % 10;
+        t1 /= 10;
+        if (flag2[num[i]])
+            return false;
+        flag2[num[i]] = true;
+        i++;
+    }
+    while (t2 > 0)
+    {
+        num[i] = t2 % 10;
+        t2 /= 10;
+        if (flag2[num[i]])
+            return false;
+        flag2[num[i]] = true;
+        i++;
+    }
+    if (i != 4)
+        return false;
+    for (i = 0; i < 10; i++)
+        if (flag1[i] != flag2[i])
+            return false;
+    return true;
+}
+
+int main()
+{
+    int i, j, count = 0;
+    for (i = 1000; i < 10000; i++)
+    {
+
+        for (j = 1; j * j <= i; j++)
+            if (!(i % j) && isOk(i, j, i / j))
+            {
+                count++;
+            }
+    }
+    cout << count << endl;
+
+    return 0;
+}
+```
+
+### B
+
+```cpp
+int main()
+{
+    int v[5], i;
+    int ans = 0;
+    for (i = 1023; i <= 9876; i++)
+    {
+        v[0] = i / 1000;
+        v[1] = i / 10 % 10;
+        v[2] = i / 100 % 10;
+        v[3] = i % 10;
+        int flag1 = 0, flag2 = 0;
+        if (v[0] != v[1] && v[0] != v[2] && v[0] != v[3] && v[1] != v[2] && v[1] != v[3] && v[2] != v[3])
+        {
+            do
+            {
+                if (flag1 != 3 && (v[0] * 100 + v[1] * 10 + v[2]) * v[3] == i)
+                {
+                    flag1 = 1;
+                    ans++;
+                }
+                else if (flag2 != 2 && (v[0] * 10 + v[1]) * (v[2] * 10 + v[3]) == i)
+                {
+                    flag2 = 2;
+                    ans++;
+                }
+                else if (flag1 != 1 && v[0] * (v[1] * 100 + v[2] * 10 + v[3]) == i)
+                {
+                    flag1 = 3;
+                    ans++;
+                }
+            } while (next_permutation(v, v + 4));
+        }
+    }
+    cout << ans;
+    return 0;
+}
+```
+
+### C
+
+```cpp
+#define MAX_N 1005
+
+bool judge1(int n)
+{
+    int ans = 0;
+    while (n)
+    {
+        ans++;
+        n /= 10;
+    }
+    if (ans == 4)
+        return true;
+    return false;
+}
+
+bool judge2(int i, int j)
+{
+    int s1 = 0, s2 = 0;
+    int ss1 = 1, ss2 = 1;
+    int tmp = i * j;
+    bool flag1 = true, flag2 = true;
+    while (tmp)
+    {
+        s1 += tmp % 10;
+        if (tmp % 10 == 0)
+            flag1 = false;
+        else
+            ss1 *= tmp % 10;
+        tmp /= 10;
+    }
+    while (j)
+    {
+        s2 += j % 10;
+        if (j % 10 != 0)
+            ss2 *= j % 10;
+        else
+            flag2 = false;
+        j /= 10;
+    }
+    while (i)
+    {
+        s2 += i % 10;
+        if (i % 10 != 0)
+            ss2 *= i % 10;
+        else
+            flag2 = false;
+        i /= 10;
+    }
+    if (s1 == s2 && ss1 == ss2 && flag1 && flag2)
+        return true;
+    else if ((!flag1 && !flag2) && s1 == s2 && ss1 == ss2)
+        return true;
+    return false;
+}
+
+bool judge3(int i, int j)
+{
+    int a[4];
+    int ans = 0;
+    while (i)
+    {
+        a[ans] = i % 10;
+        i /= 10;
+        ans++;
+    }
+    while (j)
+    {
+        a[ans] = j % 10;
+        j /= 10;
+        ans++;
+    }
+    for (i = 0; i < 3; i++)
+    {
+        for (j = i + 1; j < 4; j++)
+            if (a[i] == a[j])
+                return false;
+    }
+    return true;
+}
+
+int main()
+{
+
+    int i, j;
+    int ans = 0;
+    for (i = 1; i < 10; i++)
+    {
+        for (j = 123; j < 1000; j++)
+        {
+            if (judge1(i * j) && judge2(i, j) && judge3(i, j))
+                ans++;
+        }
+    }
+    for (i = 10; i < 100; i++)
+    {
+        for (j = i + 1; j < 100; j++)
+        {
+            if (judge1(i * j) && judge2(i, j) && judge3(i, j))
+                ans++;
+        }
+    }
+    cout << ans;
+    return 0;
+}
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..e0180cef42d52734dd77211ba88042e37841ceab
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-b788a09cd8e647738a9ac6aea903aadb",
+  "keywords": [
+    "蓝桥杯",
+    "星期一"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6864163fd5ccd7b75cf0593f7375b6ceb05578ba
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/desc.md"
@@ -0,0 +1 @@
+整个20世纪（1901年1月1日至2000年12月31日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..eb068383de690a9531c3394d17b83daee1662998
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.cpp"
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int a[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+int b[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 闰年
+int days = 0;                                                 //共多少天
+int rows = 0;                                                 //共多少行
+bool f(int n)                                                 // n是不是闰年
+{
+    if ((n % 4 == 0 && n % 100 != 0) || n % 100 == 0)
+        return true;
+    else
+        return false;
+}
+
+void print(int t[]) //打印那一年
+{
+    for (int i = 0; i < 12; i++)
+    {
+        for (int j = 1; j <= t[i]; j++)
+        {
+            cout << j << "  ";
+            days++;
+            if (days % 7 == 0) //  7天一礼拜
+            {
+                cout << endl;
+                rows++;
+            }
+        }
+    }
+}
+int main()
+{
+    int start = 1901;
+    int end = 2000;
+    for (int i = start; i <= end; i++)
+    {
+        if (f(i) == true) //是闰年,按b数组打印
+            print(b);
+        else //不是，按a数组打印
+            print(a);
+    }
+    cout << "rows is " << endl;
+    cout << rows << endl;
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..28dccebba66d6bf3a9002cf585add69700060c62
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "d246625d4b1140b3a726569ae37220fb"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\346\230\237\346\234\237\344\270\200/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..23e068e223fa556ccb60e22c54ee4f1cd88402f9
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/27.\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
+5217
+```
+
+## 选项
+
+### A
+
+```cpp
+5218
+```
+
+### B
+
+```cpp
+5216
+```
+
+### C
+
+```cpp
+5210
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..cf4df2fc12f636064b22656ddf005fac1f735e4e
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-5a3bc1e4f38648379d0f7be6d46a7648",
+  "keywords": [
+    "蓝桥杯",
+    "生日蜡烛"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..740ebb02b27c42b7c370b84d082ae8af03a7e5eb
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/desc.md"
@@ -0,0 +1,2 @@
+某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一吹熄了236根蜡烛。  
+请问，他从多少岁开始过生日party的？
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..ebd489c7d64a3acf4a772a692af26ab98a7ccc57
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.cpp"
@@ -0,0 +1,16 @@
+#include <iostream>
+using namespace std;
+int main()
+{
+    for (int i = 1; i <= 50; i++)
+    {
+        for (int j = 50; j >= i; j--)
+        {
+            if ((i + j) * (j - i + 1) == 472)
+            {
+                cout << i << " " << j << endl;
+            }
+        }
+    }
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..37965bbba89aba2eb33cbeaa2f05a05c5f66dc08
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "ff9342bf7bcc48fba2718fdde83d1c0b"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\347\224\237\346\227\245\350\234\241\347\203\233/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d1b09b7821b69336cc4fabfdea55ae3670f15eb7
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/1.\350\223\235\346\241\245\346\235\257-\345\237\272\347\241\200/30.\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
+26
+```
+
+## 选项
+
+### A
+
+```cpp
+24
+```
+
+### B
+
+```cpp
+25
+```
+
+### C
+
+```cpp
+27
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..2c822c65424bcdfcc3def1f33e68a6aa2a4717b5
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-108089b131c346dabc981230a1cb4fb1",
+  "keywords": [
+    "蓝桥杯",
+    "人物相关性分析"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..68f7bbef8c43a97dd4d647acf0175c291f12cf07
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/desc.md"
@@ -0,0 +1,39 @@
+小明正在分析一本小说中的人物相关性。
+
+他想知道在小说中 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
+```
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..680e35fc611403676b6c14346c765a016d7a2d2d
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.cpp"
@@ -0,0 +1,51 @@
+#include <bits/stdc++.h>
+using namespace std;
+int len;
+string s;
+bool check(int i)
+{
+    if (len - i < 5)
+        return false;
+    return s[i + 1] == 'l' && s[i + 2] == 'i' && s[i + 3] == 'c' && s[i + 4] == 'e';
+}
+bool check2(int i)
+{
+    if (len - i < 3)
+        return false;
+    return s[i + 1] == 'o' && s[i + 2] == 'b';
+}
+int main()
+{
+    int k; //这里绝对不能加关闭流读入，如果这加了getline会直接读不到
+    cin >> k;
+    getchar();
+    getline(cin, s);
+    len = s.length();
+    vector<int> Alice, Bob;
+    for (int i = 0; i < len; i++)
+    {
+        if (s[i] == 'A' && check(i))
+        {
+            Alice.push_back(i);
+            i += 5;
+        }
+        else if (s[i] == 'B' && check2(i))
+        {
+            Bob.push_back(i);
+            i += 3;
+        }
+    }
+    int As = Alice.size(), Bs = Bob.size();
+    int i = 0, j = 0;
+    long long ans = 0;
+    for (int q = 0; q < As; q++)
+    {
+        while (i < Bs && Bob[i] < Alice[q] - k - 3)
+            i++; //左边界已经有些被排除的
+        while (j < Bs && Bob[j] <= Alice[q] + k + 5)
+            j++; //右边界
+        ans += j - i;
+    }
+    cout << ans << "\n";
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f2c885cfbe03e3a4d5eed507a8ee8c317461a8ed
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\344\272\272\347\211\251\347\233\270\345\205\263\346\200\247\345\210\206\346\236\220/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "f79d5efd471f46ec87d7069fb765f43d"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\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/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\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..d554d5cbaeceb6057b7c26aef42a9e0ce020d1f8
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/4.\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,311 @@
+# 人物相关性分析
+
+小明正在分析一本小说中的人物相关性。
+
+他想知道在小说中 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
+#include <bits/stdc++.h>
+using namespace std;
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+int main()
+{
+    int k;
+    scanf("%d", &k);
+    getchar();
+
+    const char *a = "Alice", *b = "Bob";
+    char str[1000000];
+    gets(str);
+
+    int length = strlen(str);
+    int num = 0, i, j, t, flag;
+    char word[20];
+    for (i = 0; i < length; i++)
+    {
+        if (str[i] == 'A' || str[i] == 'B')
+        {
+            j = 0;
+            while (str[i] != ' ' && str[i] != '.')
+                word[j++] = str[i++];
+            word[j] = '\0';
+
+            flag = 0;
+            if (strcmp(word, a) == 0)
+                flag = 1;
+            else if (strcmp(word, b) == 0)
+                flag = 2;
+
+            if (flag == 1)
+            {
+                for (t = i; t < length; t++)
+                {
+                    if (str[t] == 'B')
+                    {
+                        j = 0;
+                        while (str[t] != ' ' && str[t] != '.')
+                            word[j++] = str[t++];
+                        word[j] = '\0';
+
+                        if (strcmp(word, b) == 0)
+                            num++;
+                    }
+                }
+            }
+            else if (flag == 2)
+            {
+                for (t = i; t < length; t++)
+                {
+                    if (str[t] == 'A')
+                    {
+                        j = 0;
+                        while (str[t] != ' ' && str[t] != '.')
+                            word[j++] = str[t++];
+                        word[j] = '\0';
+
+                        if (strcmp(word, a) == 0)
+                            num++;
+                    }
+                }
+            }
+        }
+    }
+    printf("%d\n", num);
+
+    return 0;
+}
+```
+
+## 选项
+
+### A
+
+```cpp
+int cnt, k;
+bool temp = true;
+char f[2][20] = {"Alice", "Bob"};
+bool check(string &a, int &pa, int &pb)
+{
+    bool flage = true;
+    pa = a.find(f[0], ++pa);
+    if (pa == -1)
+        temp = false;
+    if (temp && abs((pa - 1) - pb) < k && pb)
+        cnt++;
+    if (a[pa - 1] != ' ' && a[pa + 6] != ' ')
+        flage = false;
+    pb = a.find(f[1], ++pb);
+    if (pb == -1)
+        temp = false;
+    if (a[pb - 1] != ' ' && a[pb + 6] != ' ')
+        flage = false;
+    return flage;
+}
+int main()
+{
+    string a;
+    cin >> k;
+    getchar();
+    getline(cin, a);
+    int pa = 0, pb = 0;
+    while (1)
+    {
+        if (check(a, pa, pb) && abs(pa - pb) < k && temp)
+        {
+            cnt++;
+        }
+        else if (!temp)
+            break;
+    }
+    cout << cnt;
+    return 0;
+}
+```
+
+### B
+
+```cpp
+#define mem(a, b) memset(a, b, sizeof a)
+#define PII pair<int, int>
+#define ll long long
+#define ull unsigned long long
+#define IOS ios::sync_with_stdio(0), cin.tie(0)
+#define gcd(a, b) __gcd(a, b)
+#define ft first
+#define sd second
+#define endl '\n'
+#define PI acos(-1.0)
+#define lcm(a, b) a / gcd(a, b) * b
+#define INF_INT 0x3f3f3f3f
+#define INF_LONG 4557430888798830399
+const int N = 4e6 + 9;
+int ta, tb;
+int a[N], b[N];
+string s;
+int solve(string ss, int *cnt)
+{
+    int t = 0, n = s.size();
+    for (int i = 0; i < n; i++)
+    {
+        if (s[i] == ss[0])
+        {
+            if (i)
+            {
+                char ch = s[i - 1];
+                if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
+                    continue;
+            }
+            int flag = 1, j;
+            string tmp = "";
+            for (j = i; j < n && j - i < ss.size(); j++)
+            {
+                tmp += s[j];
+            }
+            if (tmp != ss)
+                flag = 0;
+
+            if (j < n && ((s[j] >= 'a' && s[j] <= 'z') || (s[j] >= 'A' && s[j] <= 'Z')))
+                flag = 0;
+            if (flag)
+                cnt[t++] = i;
+        }
+    }
+    return t;
+}
+int main()
+{
+    int k;
+    cin >> k;
+    getchar();
+    getline(cin, s);
+    int ta = solve("Alice", a);
+    int tb = solve("Bob", b);
+    ll ans = 0;
+    for (int i = 0, lp = 0, rp = 0; i < ta; i++)
+    {
+        while (b[lp] < a[i] - 3 - k)
+            lp++;
+        while (b[rp] <= a[i] + k + 5 && rp < tb)
+            rp++;
+
+        if (rp - lp > 0)
+            ans += (ll)(rp - lp);
+    }
+    cout << ans << endl;
+    return 0;
+}
+```
+
+### C
+
+```cpp
+int len;
+string s;
+bool check(int i)
+{
+    if (len - i < 5)
+        return false;
+    return s[i + 1] == 'l' && s[i + 2] == 'i' && s[i + 3] == 'c' && s[i + 4] == 'e';
+}
+bool check2(int i)
+{
+    if (len - i < 3)
+        return false;
+    return s[i + 1] == 'o' && s[i + 2] == 'b';
+}
+int main()
+{
+    int k;
+    cin >> k;
+    getchar();
+    getline(cin, s);
+    len = s.length();
+    vector<int> Alice, Bob;
+    for (int i = 0; i < len; i++)
+    {
+        if (s[i] == 'A' && check(i))
+        {
+            Alice.push_back(i);
+            i += 5;
+        }
+        else if (s[i] == 'B' && check2(i))
+        {
+            Bob.push_back(i);
+            i += 3;
+        }
+    }
+    int As = Alice.size(), Bs = Bob.size();
+    int i = 0, j = 0;
+    long long ans = 0;
+    for (int q = 0; q < As; q++)
+    {
+        while (i < Bs && Bob[i] < Alice[q] - k - 3)
+            i++;
+        while (j < Bs && Bob[j] <= Alice[q] + k + 5)
+            j++;
+        ans += j - i;
+    }
+    cout << ans << "\n";
+    return 0;
+}
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4376412302f2958985f75eeb1dd551ba3f3b639e
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-216aba466fa84f069f09de86439271b1",
+  "keywords": [
+    "蓝桥杯",
+    "解码"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5eea933d8954b12ff63b27aa0359310314d14864
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/desc.md"
@@ -0,0 +1,28 @@
+#### 问题描述
+
+小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
+
+例如，连续的 5 个 a，即 aaaaa，小明可以简写成 a5（也可能简写成 a4a、aa3a 等）。对于这个例子：HHHellllloo，小明可以简写成 H3el5o2。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
+现在给出简写后的字符串，请帮助小明还原成原来的串。
+
+#### 输入格式
+
+输入一行包含一个字符串。
+
+#### 输出格式
+
+输出一个字符串，表示还原后的串。
+
+#### 样例输入
+```
+H3el5o2
+```
+#### 样例输出
+```
+HHHellllloo
+```
+#### 评测用例规模与约定
+
+对于所有评测用例，字符串由大小写英文字母和数字组成，长度不超过100。
+
+请注意原来的串长度可能超过 100。
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..4e9fe079ea19a428b42878d89bf03101f3cf697f
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.cpp"
@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+using namespace std;
+char s2[100000];
+int main()
+{
+    char s1[150];
+    cin >> s1;
+
+    int top = 0;
+    for (int i = 0; s1[i] != '\0'; i++)
+    {
+        if ((s1[i] >= 'A' && s1[i] <= 'Z') || (s1[i] >= 'a' && s1[i] <= 'z'))
+        {
+            s2[top++] = s1[i];
+        }
+        else
+        {
+            while (s1[i] != '1')
+            {
+                s2[top++] = s1[i - 1];
+                s1[i] = s1[i] - 1;
+            }
+        }
+    }
+    s2[top] = '\0';
+
+    cout << s2;
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..fdc585e832dbfa17c82d6381e93167e495afc150
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "7f65d6a25e334652bfe898316850934e"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..396b4515bd07474d21beaf63fb9e1e390c690725
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/2.\350\223\235\346\241\245\346\235\257-\345\255\227\347\254\246\344\270\262/5.\350\247\243\347\240\201/solution.md"
@@ -0,0 +1,109 @@
+# 解码
+
+**问题描述**
+
+小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
+
+例如，连续的 5 个 a，即 aaaaa，小明可以简写成 a5（也可能简写成 a4a、aa3a 等）。对于这个例子：HHHellllloo，小明可以简写成 H3el5o2。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
+现在给出简写后的字符串，请帮助小明还原成原来的串。
+
+**输入格式**
+
+输入一行包含一个字符串。
+
+**输出格式**
+
+输出一个字符串，表示还原后的串。
+
+**样例输入**
+
+```
+H3el5o2
+```
+
+**样例输出**
+
+```
+HHHellllloo
+```
+
+**评测用例规模与约定**
+
+对于所有评测用例，字符串由大小写英文字母和数字组成，长度不超过100。
+
+请注意原来的串长度可能超过 100。
+
+以下程序实现了这一功能，请你填补空白处内容：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+char s2[100000];
+int main()
+{
+    char s1[150];
+    cin >> s1;
+
+    int top = 0;
+    for (int i = 0; s1[i] != '\0'; i++)
+    {
+        if ((s1[i] >= 'A' && s1[i] <= 'Z') || (s1[i] >= 'a' && s1[i] <= 'z'))
+        {
+            s2[top++] = s1[i];
+        }
+        else
+        {
+            while (s1[i] != '1')
+            {
+                __________________
+                s1[i] = s1[i] - 1;
+            }
+        }
+    }
+    s2[top] = '\0';
+
+    cout << s2;
+    return 0;
+}
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+s2[top++] = s1[i - 1];
+```
+
+## 选项
+
+### A
+
+```cpp
+s2[++top] = s1[i - 1];
+```
+
+### B
+
+```cpp
+s2[++top] = s1[i + 1];
+```
+
+### C
+
+```cpp
+s2[top++] = s1[i + 1];
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..5f98d7acccd8b1c2e98d9855442de1b2a867bbb6
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-9e407b7a4ec844019c7a4db5b61ee004",
+  "keywords": [
+    "蓝桥杯",
+    "取数位"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..80a94c169438a6695f64a171e3e1a515d41fd003
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/desc.md"
@@ -0,0 +1,4 @@
+求1个整数的第k位数字有很多种方法。
+
+以下的方法就是一种。
+
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..79d89f2f5deacaef1a5bb6b9c005c0003fcad2b3
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.cpp"
@@ -0,0 +1,20 @@
+#include <stdio.h>
+int len(int x)
+{
+    if (x < 10)
+        return 1;
+    return len(x / 10) + 1;
+}
+// 取x的第k位数字
+int f(int x, int k)
+{
+    if (len(x) - k == 0)
+        return x % 10;
+    return f(x / 10, k); //填空
+}
+int main()
+{
+    int x = 23574;
+    printf("%d\n", f(x, 3));
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..ab87f3c40f004a2592ec9faa757f16c5e034e3d3
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "4f854873186048839ba4c2a7da47f366"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..92cdf9cdba8617fdfb5ecb5e9eb2e4c7d157cddf
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/6.\345\217\226\346\225\260\344\275\215/solution.md"
@@ -0,0 +1,70 @@
+# 取数位
+
+求1个整数的第k位数字有很多种方法。
+
+以下的方法就是一种。请你填补空白处的内容：
+
+```cpp
+#include <stdio.h>
+int len(int x)
+{
+    if (x < 10)
+        return 1;
+    return len(x / 10) + 1;
+}
+
+int f(int x, int k)
+{
+    if (len(x) - k == 0)
+        return x % 10;
+    __________________
+}
+int main()
+{
+    int x = 23574;
+    printf("%d\n", f(x, 3));
+    return 0;
+}
+```
+
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+    return f(x / 10, k);
+```
+
+## 选项
+
+### A
+
+```cpp
+    return f(x % 10, k);
+```
+
+### B
+
+```cpp
+    return f(x, k);
+```
+
+### C
+
+```cpp
+    return f(x, k / 10);
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d0dd03b97c892cc6942889043498433db2688edb
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-b40b51c853e940adadaf01b5a205aa0c",
+  "keywords": [
+    "蓝桥杯",
+    "逆波兰表达式"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e0bb51c54d69289201b9d9d38dbf2bfeb00afc93
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/desc.md"
@@ -0,0 +1,14 @@
+正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。  
+例如：3 + 5 * (2 + 6) - 1  
+而且，常常需要用括号来改变运算次序。  
+相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：  
+```
+- + 3 * 5 + 2 6 1
+```
+不再需要括号，机器可以用递归的方法很方便地求解。
+为了简便，我们假设：
+1. 只有 $ + - * $ 三种运算符
+2. 每个运算数都是一个小于10的非负整数  
+
+下面的程序对一个逆波兰表示串进行求值。  
+其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。 
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..e342a718c67a832e032a8292da8f208f1be79404
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.cpp"
@@ -0,0 +1,46 @@
+#include <iostream>
+using namespace std;
+
+struct EV
+{
+    int result; //计算结果
+    int n;      //消耗掉的字符数
+};
+
+struct EV evaluate(char *x)
+{
+    struct EV ev = {0, 0};
+    struct EV v1;
+    struct EV v2;
+
+    if (*x == 0)
+        return ev;
+
+    if (x[0] >= '0' && x[0] <= '9')
+    {
+        ev.result = x[0] - '0'; //字符转数字
+        ev.n = 1;
+        return ev;
+    }
+
+    v1 = evaluate(x + 1);
+    v2 = evaluate(x + v1.n + 1);
+
+    if (x[0] == '+')
+        ev.result = v1.result + v2.result;
+    if (x[0] == '*')
+        ev.result = v1.result * v2.result;
+    if (x[0] == '-')
+        ev.result = v1.result - v2.result;
+    ev.n = 1 + v1.n + v2.n;
+
+    return ev;
+}
+
+int main(int argc, char **argv)
+{
+    string str = "-+3*5+261";
+    const EV &ev = evaluate((char *)(str.c_str()));
+    cout << ev.result << endl;
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d41245a5b3134682d546fdb9cf2bb8a442116acc
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "c29652154669434cb71e4f036b690fef"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\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..f989fa2be664cfc4f75134911bfdb029b75f8926
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/3.\350\223\235\346\241\245\346\235\257-\351\200\222\345\275\222/7.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217/solution.md"
@@ -0,0 +1,105 @@
+# 逆波兰表达式
+
+正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。  
+例如：3 + 5 * (2 + 6) - 1  
+而且，常常需要用括号来改变运算次序。  
+相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：  
+```
+- + 3 * 5 + 2 6 1
+```
+不再需要括号，机器可以用递归的方法很方便地求解。
+为了简便，我们假设：
+1. 只有 $ + - * $ 三种运算符
+2. 每个运算数都是一个小于10的非负整数  
+
+下面的程序对一个逆波兰表示串进行求值。  
+其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。 
+请你补全代码：
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct EV
+{
+    int result;
+    int n;
+};
+
+struct EV evaluate(char *x)
+{
+    struct EV ev = {0, 0};
+    struct EV v1;
+    struct EV v2;
+
+    if (*x == 0)
+        return ev;
+
+    if (x[0] >= '0' && x[0] <= '9')
+    {
+        ev.result = x[0] - '0';
+        ev.n = 1;
+        return ev;
+    }
+
+    v1 = evaluate(x + 1);
+    __________________
+
+    if (x[0] == '+')
+        ev.result = v1.result + v2.result;
+    if (x[0] == '*')
+        ev.result = v1.result * v2.result;
+    if (x[0] == '-')
+        ev.result = v1.result - v2.result;
+    ev.n = 1 + v1.n + v2.n;
+
+    return ev;
+}
+
+int main(int argc, char **argv)
+{
+    string str = "-+3*5+261";
+    const EV &ev = evaluate((char *)(str.c_str()));
+    cout << ev.result << endl;
+    return 0;
+}
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+v2 = evaluate(x + v1.n + 1);
+```
+
+## 选项
+
+### A
+
+```cpp
+v2 = evaluate(x + v1.n);
+```
+
+### B
+
+```cpp
+v2 = evaluate(v1.n);
+```
+
+### C
+
+```cpp
+v2 = evaluate(v1.n + 1);
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..aa9f5e9e1281e27136da5867e33b8ef6c7668a3c
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-e41cd4349f6d4bbdb1801a6cdc95b57a",
+  "keywords": [
+    "蓝桥杯",
+    "跑步锻炼"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..69a544275fb1555af05429f878bbd795ea2fc6e2
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/desc.md"
@@ -0,0 +1,3 @@
+小蓝每天都锻炼身体。  
+正常情况下，小蓝每天跑1千米。如果某天是周一或者月初（1日），为了激励自己，小蓝要跑2千米。如果同时是周一或月初，小蓝也是跑2千米。  
+小蓝跑步已经坚持了很长时间，从2000年1月1日周六（含）到2020年10月1日周四（含）。请问这段时间小蓝总共跑步多少千米？
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..56cb2473b5a51656d20b57f167343f05dd722b3d
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.cpp"
@@ -0,0 +1,30 @@
+#include <bits/stdc++.h>
+using namespace std;
+int M[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+int main()
+{
+    int y = 2000, m = 1, d = 1, w = 6, ans = 2;
+    while (y != 2020 || m != 10 || d != 1)
+    {
+        if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
+            M[2] = 29;
+        else
+            M[2] = 28;
+        d++;
+        w = (w + 1) % 7;
+        if (d > M[m])
+        {
+            d = 1;
+            m++;
+            if (m > 12)
+            {
+                y++;
+                m = 1;
+            }
+        }
+        if (d == 1 || w == 1)
+            ans++;
+        ans++;
+    }
+    cout << ans;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d66b4922805d79d209427f27acb1ce1b6aa484cd
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "ebc12c88b5f049f684c3e7b63f44b6d7"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\350\267\221\346\255\245\351\224\273\347\202\274/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..58cd5a2c4e6759cdd60f96a1cbe325af832e9963
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/5.\350\223\235\346\241\245\346\235\257-\346\250\241\346\213\237/11.\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
+8879
+```
+
+## 选项
+
+### A
+
+```cpp
+8888
+```
+
+### B
+
+```cpp
+8880
+```
+
+### C
+
+```cpp
+8808
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4eee35b081e03ef91de10f6d5dd3a7c38037a7ac
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-daed047610e942a6bb5548f7acacdf3b",
+  "keywords": [
+    "蓝桥杯",
+    "跳蚱蜢"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5867dbe89dc3b67a317512f309b3de51b0ec4b4f
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/desc.md"
@@ -0,0 +1,11 @@
+有 9 只盘子，排成 1 个圆圈。
+
+其中 8 只盘子内装着 8 只蚱蜢，有一个是空盘，我们把这些蚱蜢顺时针编号为 1 ~ 8
+
+每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
+
+请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
+
+并且保持空盘的位置不变（也就是 1-8 换位，2-7 换位,…），至少要经过多少次跳跃？
+
+![](https://img-blog.csdnimg.cn/20200530104930106.png)
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..a65346d145a6963d009f405b88d464708c6b89a9
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.cpp"
@@ -0,0 +1,44 @@
+#include <iostream>
+#include <unordered_map>
+#include <queue>
+using namespace std;
+
+int dir[] = {1, -1, 2, -2};
+unordered_map<string, int> dist;
+string S = "12345678X", T = "87654321X";
+
+int bfs()
+{
+    queue<string> q;
+    q.push(S);
+    dist[S] = 0;
+
+    while (q.size())
+    {
+        string t = q.front();
+        q.pop();
+
+        if (t == T)
+            return dist[t];
+
+        int k = t.find('X'), distance = dist[t];
+        for (int i = 0; i < 4; i++)
+        {
+            swap(t[k], t[(k + dir[i] + 9) % 9]);
+            if (!dist.count(t))
+            {
+                q.push(t);
+                dist[t] = distance + 1;
+            }
+            swap(t[k], t[(k + dir[i] + 9) % 9]);
+        }
+    }
+
+    return -1;
+}
+
+int main()
+{
+    cout << bfs() << endl;
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..4b3b3aa63abe4fc4d964cbb3b54c1bf57b9ff0af
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "f6527d9cc83345379fe1fedfa52a3b6a"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fef83732fa7141312e38c97f9d4e8369f11b1d9b
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/10.\350\267\263\350\232\261\350\234\242/solution.md"
@@ -0,0 +1,259 @@
+# 跳蚱蜢
+
+有 9 只盘子，排成 1 个圆圈。
+
+其中 8 只盘子内装着 8 只蚱蜢，有一个是空盘，我们把这些蚱蜢顺时针编号为 1 ~ 8
+
+每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
+
+请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
+
+并且保持空盘的位置不变（也就是 1-8 换位，2-7 换位,…），至少要经过多少次跳跃？
+
+![](https://img-blog.csdnimg.cn/20200530104930106.png)
+
+以下选项错误的是？
+
+## aop
+
+### before
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+const int MAXN = 1e7;
+
+int arr[9] = {4, 3, 2, 1, 0, 8, 7, 6, 5};
+
+int tar[9] = {5, 6, 7, 8, 0, 1, 2, 3, 4};
+
+int que[MAXN][9];
+
+int dist[MAXN];
+
+int pos[MAXN];
+
+struct cmp
+{
+    bool operator()(int a, int b)
+    {
+        return memcmp(que[a], que[b], sizeof(int) * 9) < 0;
+    }
+};
+
+set<int, cmp> vis;
+
+void set_init()
+{
+    vis.clear();
+}
+
+bool inset_check(int a)
+{
+    if (vis.find(a) == vis.end())
+    {
+        vis.insert(a);
+        return true;
+    }
+    return false;
+}
+
+int bfs()
+{
+
+    int front = 1;
+    int rear = 2;
+    pos[front] = 4;
+    dist[front] = 0;
+    memcpy(que[front], arr, sizeof(int) * 9);
+
+    while (front < rear)
+    {
+        int *a = que[front];
+
+        if (memcmp(a, tar, sizeof(int) * 9) == 0)
+            return front;
+
+        for (int i = -2; i <= 2; i++)
+        {
+            if (i == 0)
+                continue;
+
+            int new_pos = (pos[front] + i + 9) % 9;
+            int *t = que[rear];
+            memcpy(t, a, sizeof(int) * 9);
+            dist[rear] = dist[front];
+
+            t[new_pos] = a[pos[front]];
+            t[pos[front]] = a[new_pos];
+            pos[rear] = new_pos;
+
+            if (inset_check(rear))
+                rear++;
+        }
+        front++;
+    }
+    return 0;
+}
+
+int main()
+{
+    int ans = bfs();
+    printf("%d\n", dist[ans]);
+
+    return 0;
+}
+```
+
+## 选项
+
+### A
+
+```cpp
+string start = "012345678";
+string e = "087654321";
+int main()
+{
+    queue<pair<string, int>> q;
+    q.push(make_pair(start, 0));
+    set<string> s;
+    s.insert(start);
+    while (!q.empty())
+    {
+        string a = q.front().first;
+        int level = q.front().second;
+        if (a == e)
+        {
+            cout << level;
+            break;
+        }
+        q.pop();
+        int pos = 0;
+        while (a[pos] != '0')
+            pos++;
+        int posi[4];
+        posi[0] = (pos + 8) % 9;
+        posi[1] = (pos + 1) % 9;
+        posi[2] = (pos + 7) % 9;
+        posi[3] = (pos + 2) % 9;
+        for (int i = 0; i < 4; i++)
+        {
+            string b = a;
+            b[pos] = b[posi[i]];
+            b[posi[i]] = '0';
+            if (s.count(b) == 0)
+            {
+                s.insert(b);
+                q.push(make_pair(b, level + 1));
+            }
+        }
+    }
+    return 0;
+}
+```
+
+### B
+
+```cpp
+struct node
+{
+    string str;
+    int pos;
+    int step;
+    node(string str, int pos, int step) : str(str), pos(pos), step(step) {}
+};
+int N = 9;
+set<string> visited;
+queue<node> q;
+void insertq(node no, int i)
+{
+    string s = no.str;
+    swap(s[no.pos], s[(no.pos + i + 9) % 9]);
+
+    if (visited.count(s) == 0)
+    {
+        visited.insert(s);
+        node n(s, (no.pos + i + 9) % 9, no.step + 1);
+        q.push(n);
+    }
+}
+int main()
+{
+    node first("012345678", 0, 0);
+    q.push(first);
+
+    while (!q.empty())
+    {
+        node temp = q.front();
+        if (temp.str == "087654321")
+        {
+            cout << temp.step;
+            break;
+        }
+        else
+        {
+
+            insertq(temp, 1);
+            insertq(temp, -1);
+            insertq(temp, 2);
+            insertq(temp, -2);
+            q.pop();
+        }
+    }
+}
+```
+
+### C
+
+```cpp
+int dir[] = {1, -1, 2, -2};
+unordered_map<string, int> dist;
+string S = "12345678X", T = "87654321X";
+
+int bfs()
+{
+    queue<string> q;
+    q.push(S);
+    dist[S] = 0;
+
+    while (q.size())
+    {
+        string t = q.front();
+        q.pop();
+
+        if (t == T)
+            return dist[t];
+
+        int k = t.find('X'), distance = dist[t];
+        for (int i = 0; i < 4; i++)
+        {
+            swap(t[k], t[(k + dir[i] + 9) % 9]);
+            if (!dist.count(t))
+            {
+                q.push(t);
+                dist[t] = distance + 1;
+            }
+            swap(t[k], t[(k + dir[i] + 9) % 9]);
+        }
+    }
+
+    return -1;
+}
+
+int main()
+{
+    cout << bfs() << endl;
+    return 0;
+}
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..f608dc87c377c11b61a20ab2787c3c60aa560b95
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-268291e6cb264bce97c6919f98c2c8f0",
+  "keywords": [
+    "蓝桥杯",
+    "网络分析"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fc78b7fe54edbc118de0e888ac6363bccb9ec1fe
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/desc.md"
@@ -0,0 +1,40 @@
+#### 问题描述
+小明正在做一个网络实验。
+他设置了 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。
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..75f8e7e13aa3361eadee07d04a8cae05b3d3b7d4
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.cpp"
@@ -0,0 +1,52 @@
+#include <iostream>
+#include <cstdio>
+#include <cstring>
+
+using namespace std;
+const int maxn = 10005;
+int a[maxn][maxn];
+int dfs_vis[maxn];
+int n, m;
+
+struct Node
+{
+    int data;
+} Point[maxn];
+
+void DFS(int a[maxn][maxn], int x, int y)
+{
+    Point[x].data += y;
+    dfs_vis[x] = 1;
+    for (int i = 1; i <= n; i++)
+    {
+        if (a[x][i] == 1 && dfs_vis[i] == 0)
+        {
+            DFS(a, i, y);
+        }
+    }
+}
+int main()
+{
+    cin >> n >> m;
+    cin.get();
+
+    for (int i = 1; i <= m; i++)
+    {
+        int flag, x1, x2;
+        scanf("%d %d %d", &flag, &x1, &x2);
+        if (flag == 1)
+        {
+            a[x1][x2] = a[x2][x1] = 1;
+        }
+        else if (flag == 2)
+        {
+            memset(dfs_vis, 0, sizeof(dfs_vis));
+            DFS(a, x1, x2);
+        }
+    }
+    for (int i = 1; i <= n; ++i)
+    {
+        cout << Point[i].data << " ";
+    }
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..fa8b65e2c556605149e2ca179e2011dcebc70d45
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "1cd422764c9f4e5f9842a3195b91a919"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..00767554e3615620e92e4c5ed112bb9d7974a35e
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/11.\347\275\221\347\273\234\345\210\206\346\236\220/solution.md"
@@ -0,0 +1,355 @@
+# 网络分析
+
+
+**问题描述**
+
+小明正在做一个网络实验。
+他设置了 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
+#include <bits/stdc++.h>
+using namespace std;
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+int main()
+{
+    int n = 0;
+    int m = 0;
+    cin >> n;
+    cin >> m;
+    int ar[n + 1][n + 1];
+
+    for (int i = 0; i < n + 1; i++)
+        for (int j = 0; j < n + 1; j++)
+            ar[i][j] = 0;
+
+    bool arJudge[n + 1];
+
+    for (int i = 0; i < n + 1; i++)
+        arJudge[i] = 0;
+
+    vector<int> v(n, 0);
+    for (int i = 0; i <= n; ++i)
+    {
+        for (int j = 0; j <= n; ++j)
+        {
+            ar[i][j] = 0;
+        }
+    }
+
+    int a = 0, b = 0, c = 0;
+    for (int i = 0; i < m; ++i)
+    {
+        cin >> a;
+        cin >> b;
+        cin >> c;
+        if (a == 1)
+        {
+            if (ar[b][c] == 0)
+            {
+                ar[b][c] = 1;
+            }
+
+            if (ar[c][b] == 0)
+            {
+                ar[c][b] = 1;
+            }
+        }
+        if (a == 2)
+        {
+            queue<int> que;
+            que.push(b);
+            while (!que.empty())
+            {
+                int size = que.size();
+
+                for (int i = 0; i < size; ++i)
+                {
+                    int temp = que.front();
+                    que.pop();
+                    if (arJudge[temp] == 0)
+                    {
+                        v[temp - 1] += c;
+                        arJudge[temp] = 1;
+                    }
+                    for (int j = 1; j <= n; ++j)
+                    {
+                        if (ar[temp][j] != 0)
+                        {
+                            que.push(j);
+                        }
+                    }
+                }
+            }
+        }
+        for (int i = 0; i <= n; ++i)
+        {
+            arJudge[i] = 0;
+        }
+    }
+
+    for (int i = 1; i <= n; ++i)
+    {
+        for (int j = 1; j <= n; ++j)
+        {
+            cout << ar[i][j] << " ";
+        }
+        cout << endl;
+    }
+    for (int i = 0; i < n; ++i)
+    {
+        cout << v[i] << " ";
+    }
+    cout << endl;
+    return 0;
+}
+```
+
+## 选项
+
+### A
+
+```cpp
+int const N = 10010;
+using namespace std;
+int n, m;
+int i, j, k;
+int num[N];
+
+int f[N];
+
+int r[N];
+
+void init()
+{
+    for (i = 1; i <= n; i++)
+    {
+        f[i] = i;
+        r[i] = 1;
+    }
+}
+
+int find(int x)
+{
+    return f[x] == x ? x : (f[x] = find(f[x]));
+}
+
+void send(int x, int y)
+{
+    int tempx, tempy;
+
+    tempx = find(x);
+    tempy = find(y);
+    if (r[tempx] >= r[tempy])
+    {
+
+        f[tempy] = tempx;
+    }
+    else
+    {
+        f[tempx] = tempy;
+    }
+    if (r[tempx] == r[tempy] && tempx != tempy)
+    {
+        r[tempx]++;
+    }
+}
+void count(int x, int y)
+{
+    int tempx;
+    tempx = find(x);
+    for (i = 1; i <= n; i++)
+    {
+        if (tempx == find(i))
+        {
+            num[i] += y;
+        }
+    }
+}
+int main()
+{
+    cin >> n >> m;
+    init();
+    while (m--)
+    {
+        int x, y, z;
+        cin >> x >> y >> z;
+        if (x == 1)
+        {
+            send(y, z);
+        }
+        if (x == 2)
+        {
+            count(y, z);
+        }
+    }
+    for (i = 1; i <= n; i++)
+    {
+        cout << num[i] << " ";
+    }
+    return 0;
+}
+```
+
+### B
+
+```cpp
+const int N = 10010;
+int p[N], d[N];
+int find(int x)
+{
+    if (p[x] == x || p[p[x]] == p[x])
+        return p[x];
+    int r = find(p[x]);
+    d[x] += d[p[x]];
+    p[x] = r;
+    return r;
+}
+int main()
+{
+    int n, m;
+    cin >> n >> m;
+    for (int i = 1; i <= n; i++)
+        p[i] = i;
+    while (m--)
+    {
+        int t, a, b;
+        cin >> t >> a >> b;
+        if (t == 1)
+        {
+            a = find(a), b = find(b);
+            if (a != b)
+            {
+                d[a] -= d[b];
+                p[a] = b;
+            }
+        }
+        else
+        {
+            a = find(a);
+            d[a] += b;
+        }
+    }
+    for (int i = 1; i <= n; i++)
+        if (i == find(i))
+            cout << d[i] << " ";
+        else
+            cout << d[i] + d[find(i)] << " ";
+    cout << endl;
+    return 0;
+}
+```
+
+### C
+
+```cpp
+const int maxn = 10005;
+int a[maxn][maxn];
+int dfs_vis[maxn];
+int n, m;
+
+struct Node
+{
+    int data;
+} Point[maxn];
+
+void DFS(int a[maxn][maxn], int x, int y)
+{
+    Point[x].data += y;
+    dfs_vis[x] = 1;
+    for (int i = 1; i <= n; i++)
+    {
+        if (a[x][i] == 1 && dfs_vis[i] == 0)
+        {
+            DFS(a, i, y);
+        }
+    }
+}
+int main()
+{
+    cin >> n >> m;
+    cin.get();
+
+    for (int i = 1; i <= m; i++)
+    {
+        int flag, x1, x2;
+        scanf("%d %d %d", &flag, &x1, &x2);
+        if (flag == 1)
+        {
+            a[x1][x2] = a[x2][x1] = 1;
+        }
+        else if (flag == 2)
+        {
+            memset(dfs_vis, 0, sizeof(dfs_vis));
+            DFS(a, x1, x2);
+        }
+    }
+    for (int i = 1; i <= n; ++i)
+    {
+        cout << Point[i].data << " ";
+    }
+    return 0;
+}
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..36a3a9b667dda5828aee4a9201c69ea0d598fe47
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-57652e0b6b054bb7871b0ec49edf5814",
+  "keywords": [
+    "蓝桥杯",
+    "李白打酒"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..78d829acb4d2bdcc173dd2564bffa379b407431e
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/desc.md"
@@ -0,0 +1,6 @@
+话说大诗人李白，一生好饮。幸好他从不开车。  
+一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：  
+无事街上走，提壶去打酒。  
+逢店加一倍，遇花喝一斗。  
+这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。   
+请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..917304f08a8ae27c0654af34afaa8964d31f9737
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.cpp"
@@ -0,0 +1,19 @@
+#include <iostream>
+using namespace std;
+
+int sum = 0;               //注意这里的sum需要是全局变量，否则在函数体内会每次都被初始化为0，无法达到计数效果
+int f(int a, int b, int c) //a代表遇到的是店，b代表遇到的是花，c代表酒的总量
+{
+    if (a > 0)
+        f(a - 1, b, 2 * c); //逢店加一倍，同时遇到的店个数 -1
+    if (b > 0)
+        f(a, b - 1, c - 1);         //遇花喝一斗，同时遇到的花个数 -1
+    if (a == 0 && b == 0 && c == 1) //这里的c为1，是因为最后遇到的是花，所以最后遇到花的情况在这里不考虑，那么遇到
+        sum += 1;                   //花之前还剩1斗
+    return sum;                     //因为需要多次调用这个函数，所以不能在函数体里输出sum
+}
+int main(void)
+{
+    cout << f(5, 9, 2) << endl;
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..33a178096559d337d21624ae9893f1daa483d7b2
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "cd0ddced79924660889797a1875dd99c"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7a95c8b6695dfad37259b2a8789f9c4aa315ea94
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/8.\346\235\216\347\231\275\346\211\223\351\205\222/solution.md"
@@ -0,0 +1,150 @@
+# 李白打酒
+
+话说大诗人李白，一生好饮。幸好他从不开车。  
+一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：  
+无事街上走，提壶去打酒。  
+逢店加一倍，遇花喝一斗。  
+这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。   
+请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
+
+以下错误的一项是？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+int main()
+{
+    int a[15] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, 2, 2, 2};
+
+    int n = 0;
+    do
+    {
+        int sum = 2;
+
+        for (int i = 0; i < 15; i++)
+        {
+            if (a[i] == -1)
+            {
+                sum += a[i];
+            }
+            else
+            {
+                sum *= a[i];
+            }
+        }
+
+        if (a[14] == -1)
+        {
+            n += 1;
+        }
+
+    } while (next_permutation(a, a + 15));
+
+    cout << n << endl;
+    return 0;
+}
+```
+
+## 选项
+
+### A
+
+```cpp
+int res = 0;
+
+void f(int dian, int hua, int jiu)
+{
+    if (dian == 0 && hua == 0 && jiu == 1)
+    {
+        res++;
+    }
+    if (dian > 0)
+        f(dian - 1, hua, jiu * 2);
+    if (hua > 0)
+        f(dian, hua - 1, jiu - 1);
+}
+
+int main(int argc, char **argv)
+{
+
+    f(5, 9, 2);
+    cout << res << endl;
+    return 0;
+}
+```
+
+### B
+
+```cpp
+int main()
+{
+    int ans = 0;
+    for (int i = 0; i < (1 << 14); ++i)
+    {
+        int tot_1 = 0;
+        int tot_0 = 0;
+        int num = 2;
+        for (int j = 0; j < 14; ++j)
+        {
+            if (i & (1 << j))
+            {
+                tot_1++;
+                num = num * 2;
+            }
+            else
+            {
+                tot_0++;
+                num = num - 1;
+            }
+        }
+        if (tot_1 == 5 && tot_0 == 9 && num == 1)
+        {
+            ++ans;
+        }
+    }
+    cout << ans;
+}
+```
+
+### C
+
+```cpp
+int cnt;
+
+void dfs(int a, int b, int sum, int u, int flag)
+{
+    if (u == 15)
+    {
+        if (a == 5 && b == 10 && sum == 0 && flag == 0)
+        {
+            cnt++;
+            return;
+        }
+    }
+    else
+    {
+        dfs(a + 1, b, sum * 2, u + 1, 1);
+        dfs(a, b + 1, sum - 1, u + 1, 0);
+    }
+}
+int main()
+{
+    dfs(0, 0, 2, 0, 0);
+    cout << cnt;
+    return 0;
+}
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..04108869d2d66250402ca1b042fdc520f4698cc4
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-8a4019c4beb049c4ab7accb34629f72d",
+  "keywords": [
+    "蓝桥杯",
+    "迷宫"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..153a74bcd70a4b4226c8f12a97946e9b1ee6ba7b
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/desc.md"
@@ -0,0 +1,44 @@
+#### 问题描述
+下图给出了一个迷宫的平面图，其中标记为 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
+
+```
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..da91317a0640ba1fd44c9472c2124da78cc91c8d
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.cpp"
@@ -0,0 +1,76 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <queue>
+#include <set>
+using namespace std;
+
+#define N 30
+#define M 50
+
+char map[N][M];
+int dir[4][2] = {{1, 0}, {0, -1}, {0, 1}, {-1, 0}}; //D<L<R<U
+char ch[4] = {'D', 'L', 'R', 'U'};
+int vis[N][M] = {0};
+
+struct point
+{
+    int x, y;
+    string road;
+    point(int a, int b)
+    {
+        x = a;
+        y = b;
+    }
+};
+
+void bfs()
+{
+    queue<point> q;
+    point p(0, 0);
+    p.road = "";
+    q.push(p);
+    vis[0][0] = 1;
+    while (!q.empty())
+    {
+        point t = q.front();
+        q.pop();
+        if (t.x == N - 1 && t.y == M - 1)
+        {
+            cout << t.road << endl;
+            break;
+        }
+        for (int i = 0; i < 4; i++)
+        {
+            int dx = t.x + dir[i][0];
+            int dy = t.y + dir[i][1];
+            if (dx >= 0 && dx < N && dy >= 0 && dy < M)
+            {
+                if (map[dx][dy] == '0' && !vis[dx][dy])
+                {
+                    point tt(dx, dy);
+                    tt.road = t.road + ch[i]; //记录路径
+                    q.push(tt);
+                    vis[dx][dy] = 1;
+                }
+            }
+        }
+    }
+}
+
+int main()
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < M; j++)
+            scanf("%c", &map[i][j]);
+        getchar(); //读掉回车
+    }
+    bfs();
+    return 0;
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..d45be10ae4bfaf0a0831cdda13532e0a1169df11
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "7ccd50fabede40e8a54a998c04c8bb42"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..536fdb3dfc0b7c4809983282170b1265b54761a9
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/6.\350\223\235\346\241\245\346\235\257-\346\220\234\347\264\242/9.\350\277\267\345\256\253/solution.md"
@@ -0,0 +1,157 @@
+# 迷宫
+
+**问题描述**
+
+下图给出了一个迷宫的平面图，其中标记为 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
+```
+
+下面的程序实现了这一功能，请你补全空白处：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+char mp[55][55];
+int book[55][55];
+int block[55][55];
+int minns[55][55];
+int minn = 100000;
+int dx[4] = {1, 0, 0, -1};
+int dy[4] = {0, -1, 1, 0};
+char dir[4] = {'D', 'L', 'R', 'U'};
+char road[1000];
+char roadans[1000];
+int step;
+
+void dfs(int x, int y, int step)
+{
+    if (x == 29 && y == 49)
+    {
+        if (step < minn)
+        {
+            minn = step;
+            for (int i = 0; i < minn; i++)
+                roadans[i] = road[i];
+        }
+        return;
+    }
+
+    for (int i = 0; i < 4; i++)
+    {
+        int tx = x + dx[i];
+        int ty = y + dy[i];
+        if (tx >= 0 && tx < 30 && ty >= 0 && ty < 50 && book[tx][ty] == 0 && block[tx][ty] == 0 && step + 1 < minns[tx][ty])
+        {
+            book[tx][ty] = 1;
+            road[step] = dir[i];
+            minns[tx][ty] = step + 1;
+            __________________
+            book[tx][ty] = 0;
+        }
+    }
+    return;
+}
+
+int main()
+{
+    for (int i = 0; i < 30; i++)
+    {
+        for (int j = 0; j < 50; j++)
+        {
+            char c;
+            cin >> c;
+            mp[i][j] = c;
+            minns[i][j] = 10000;
+            if (c == '1')
+                block[i][j] = 1;
+        }
+    }
+    book[0][0] = 1;
+    dfs(0, 0, 0);
+    for (int i = 0; i < minn; i++)
+        cout << roadans[i];
+
+    return 0;
+}
+```
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+            dfs(tx, ty, step + 1);
+```
+
+## 选项
+
+### A
+
+```cpp
+            dfs(tx, ty, step);
+```
+
+### B
+
+```cpp
+            dfs(tx + 1, ty + 1, step + 1);
+```
+
+### C
+
+```cpp
+            dfs(tx - 1, ty - 1, step + 1);
+```
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/config.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/config.json"
new file mode 100644
index 0000000000000000000000000000000000000000..fbdc24a65debb38137baf752608449df2f6b6de1
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/config.json"
@@ -0,0 +1,9 @@
+{
+  "node_id": "algorithm-10be8e52e39c4281a5a4bcba071261fa",
+  "keywords": [
+    "蓝桥杯",
+    "组合数问题"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/desc.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/desc.md"
new file mode 100644
index 0000000000000000000000000000000000000000..5f32da8bbcf7d4b8f3b97978609bb70a18f13a85
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/desc.md"
@@ -0,0 +1,46 @@
+#### 问题描述
+给 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 个评测用例测试你的程序
+```
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.cpp" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.cpp"
new file mode 100644
index 0000000000000000000000000000000000000000..bb40fb08fc607aefba627d8fa41a772d7ab87ff4
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.cpp"
@@ -0,0 +1,50 @@
+#include <bits/stdc++.h>
+using namespace std;
+#define modk(x) (((x) >= k) ? ((x)-k) : (x))
+const int maxn = 2005;
+int c[maxn][maxn], n, m, k, T;
+void init()
+{
+    ///预处理C(i,j)
+    c[0][0] = 1;
+    for (int i = 1; i < maxn; i++)
+    {
+        c[i][0] = 1 % k;
+        for (int j = 1; j <= i; j++)
+        {
+            c[i][j] = modk(c[i - 1][j] + c[i - 1][j - 1]);
+        }
+    }
+    ///处理C(i,j)是否为k 的倍数
+    for (int i = 0; i < maxn; i++)
+    {
+        for (int j = 0; j <= i; j++)
+        {
+            if (c[i][j] == 0)
+                c[i][j] = 1;
+            else
+                c[i][j] = 0;
+        }
+    }
+    ///将二维数组C处理成区域前缀和
+    for (int i = 1; i < maxn; i++)
+    {
+        int s = 0;
+        for (int j = 0; j < maxn; j++)
+        {
+            s += c[i][j];
+            c[i][j] = c[i - 1][j] + s;
+        }
+    }
+}
+int main()
+{
+    scanf("%d%d", &T, &k);
+    init();
+    while (T--)
+    {
+        scanf("%d%d", &n, &m);
+        printf("%d\n", c[n][m]);
+    }
+    return 0;
+}
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.java" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.java"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.json" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.json"
new file mode 100644
index 0000000000000000000000000000000000000000..27a3659ccdc0e6ff8e5540866c33c500cd6ac74e
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.json"
@@ -0,0 +1,6 @@
+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "3c3985435f414d7f9a8bbdcf42a42d46"
+}
\ No newline at end of file
diff --git "a/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.md" "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.md"
new file mode 100644
index 0000000000000000000000000000000000000000..687bb316e211cc07b558223981a2d0cb200063fe
--- /dev/null
+++ "b/data/1.\347\256\227\346\263\225\345\210\235\351\230\266/7.\350\223\235\346\241\245\346\235\257-\345\212\250\346\200\201\350\247\204\345\210\222/5.\347\273\204\345\220\210\346\225\260\351\227\256\351\242\230/solution.md"
@@ -0,0 +1,253 @@
+# 组合数问题
+
+
+**问题描述**
+
+给 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
+const int Mod = 1e9 + 7;
+int c[2010][2010];
+int main()
+{
+    int n, m, t, k;
+    cin >> t >> k;
+    int nn = 2000, mm = 2000;
+    for (int i = 0; i <= nn; i++)
+    {
+        c[i][0] = 1;
+        c[i][i] = 1;
+    }
+    for (int i = 1; i <= nn; i++)
+        for (int j = 1; j <= mm; j++)
+            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % k;
+    while (t--)
+    {
+        cin >> n >> m;
+        int ans = 0;
+        for (int j = 0; j <= m; j++)
+            for (int i = j; i <= n; i++)
+                if (c[i][j] == 0)
+                    ans++;
+        cout << ans % Mod;
+    }
+    return 0;
+}
+```
+
+### B
+
+```cpp
+#define modk(x) (((x) >= k) ? ((x)-k) : (x))
+const int maxn = 2005;
+int c[maxn][maxn], n, m, k, T;
+void init()
+{
+
+    c[0][0] = 1;
+    for (int i = 1; i < maxn; i++)
+    {
+        c[i][0] = 1 % k;
+        for (int j = 1; j <= i; j++)
+        {
+            c[i][j] = modk(c[i - 1][j] + c[i - 1][j - 1]);
+        }
+    }
+
+    for (int i = 0; i < maxn; i++)
+    {
+        for (int j = 0; j <= i; j++)
+        {
+            if (c[i][j] == 0)
+                c[i][j] = 1;
+            else
+                c[i][j] = 0;
+        }
+    }
+
+    for (int i = 1; i < maxn; i++)
+    {
+        int s = 0;
+        for (int j = 0; j < maxn; j++)
+        {
+            s += c[i][j];
+            c[i][j] = c[i - 1][j] + s;
+        }
+    }
+}
+int main()
+{
+    scanf("%d%d", &T, &k);
+    init();
+    while (T--)
+    {
+        scanf("%d%d", &n, &m);
+        printf("%d\n", c[n][m]);
+    }
+    return 0;
+}
+```
+
+### C
+
+```cpp
+const int Mod = 1e9 + 7;
+const int inv_2 = 5e8 + 4;
+
+long long cal(long long x, long long y)
+{
+    if (x < y)
+    {
+        x %= Mod;
+        return (x + 2) * (x + 1) % Mod * inv_2 % Mod;
+    }
+    x %= Mod, y %= Mod;
+    return ((y + 2) * (y + 1) % Mod * inv_2 % Mod + (x - y) * (y + 1) % Mod) % Mod;
+}
+long long cal_1(long long x, long long y)
+{
+    return min(x, y) + 1;
+}
+long long cal_2(long long x, long long y)
+{
+    if (x < y)
+    {
+        return 0;
+    }
+    return x - y + 1;
+}
+
+int main()
+{
+    int t, k;
+    cin >> t >> k;
+    long long n, m;
+    int a[100], b[100];
+    for (int turn = 0; turn < t; ++turn)
+    {
+        cin >> n >> m;
+        if (m > n)
+            m = n;
+        long long ans = cal(n, m);
+        int len_a = 0, len_b = 0;
+        while (n)
+        {
+            a[len_a++] = n % k;
+            n /= k;
+        }
+        while (m)
+        {
+            b[len_b++] = m % k;
+            m /= k;
+        }
+        int len = max(len_a, len_b);
+        vector<vector<long long>> dp(len + 1, vector<long long>(4));
+        dp[len][3] = 1;
+        for (int i = len - 1; i >= 0; --i)
+        {
+            dp[i][0] = dp[i + 1][0] * cal(k - 1, k - 1) + dp[i + 1][1] * cal(a[i] - 1, k - 1) + dp[i + 1][2] * cal(k - 1, b[i] - 1) + dp[i + 1][3] * cal(a[i] - 1, b[i] - 1);
+            dp[i][1] = dp[i + 1][1] * cal_1(a[i], k - 1) + dp[i + 1][3] * cal_1(a[i], b[i] - 1);
+            dp[i][2] = dp[i + 1][2] * cal_2(k - 1, b[i]) + dp[i + 1][3] * cal_2(a[i] - 1, b[i]);
+            dp[i][3] = dp[i + 1][3] & (a[i] >= b[i]);
+            dp[i][0] %= Mod, dp[i][1] %= Mod;
+            dp[i][2] %= Mod, dp[i][3] %= Mod;
+        }
+        ans -= dp[0][0] + dp[0][1] + dp[0][2] + dp[0][3];
+        ans %= Mod;
+        if (ans < 0)
+            ans += Mod;
+        cout << ans << endl;
+    }
+    return 0;
+}
+```
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"
index a9aa8b9a0486ea1460fcc4da9e6e3e1a567bd182..c6969e72d8075798160baf9669967e2f4f9764f0 100644
--- "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"
@@ -32,6 +32,43 @@
 574
 ```
 
+以下代码实现了这一功能，请你填补空白处的内容：
+
+```cpp
+#include <iostream>
+
+using namespace std;
+
+int ans, n;
+
+bool check(int n)
+{
+    while (n)
+    {
+        int tmpn = n % 10;
+        if (tmpn == 2 || tmpn == 0 || tmpn == 1 || tmpn == 9)
+            return true;
+        __________________
+    }
+    return false;
+}
+
+int main()
+{
+    cin >> n;
+
+    for (int i = 1; i <= n; i++)
+    {
+        if (check(i))
+            ans += i;
+    }
+
+    cout << ans << endl;
+
+    return 0;
+}
+```
+
 
 ## aop
 
@@ -50,7 +87,7 @@
 ## 答案
 
 ```cpp
-
+        n /= 10;
 ```
 
 ## 选项
@@ -58,17 +95,17 @@
 ### A
 
 ```cpp
-
+        n %= 10;
 ```
 
 ### B
 
 ```cpp
-
+        break;
 ```
 
 ### C
 
 ```cpp
-
+        continue;
 ```
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"
index 0713c2d4e94e0a5ebe744bbd483bd3300b6120f7..f989fa2be664cfc4f75134911bfdb029b75f8926 100644
--- "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"
@@ -14,7 +14,55 @@
 
 下面的程序对一个逆波兰表示串进行求值。  
 其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。 
-
+请你补全代码：
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct EV
+{
+    int result;
+    int n;
+};
+
+struct EV evaluate(char *x)
+{
+    struct EV ev = {0, 0};
+    struct EV v1;
+    struct EV v2;
+
+    if (*x == 0)
+        return ev;
+
+    if (x[0] >= '0' && x[0] <= '9')
+    {
+        ev.result = x[0] - '0';
+        ev.n = 1;
+        return ev;
+    }
+
+    v1 = evaluate(x + 1);
+    __________________
+
+    if (x[0] == '+')
+        ev.result = v1.result + v2.result;
+    if (x[0] == '*')
+        ev.result = v1.result * v2.result;
+    if (x[0] == '-')
+        ev.result = v1.result - v2.result;
+    ev.n = 1 + v1.n + v2.n;
+
+    return ev;
+}
+
+int main(int argc, char **argv)
+{
+    string str = "-+3*5+261";
+    const EV &ev = evaluate((char *)(str.c_str()));
+    cout << ev.result << endl;
+    return 0;
+}
+```
 
 ## aop
 
@@ -33,7 +81,7 @@
 ## 答案
 
 ```cpp
-
+v2 = evaluate(x + v1.n + 1);
 ```
 
 ## 选项
@@ -41,17 +89,17 @@
 ### A
 
 ```cpp
-
+v2 = evaluate(x + v1.n);
 ```
 
 ### B
 
 ```cpp
-
+v2 = evaluate(v1.n);
 ```
 
 ### C
 
 ```cpp
-
+v2 = evaluate(v1.n + 1);
 ```
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"
index a7a4692e9a70434411f0974d34123f4310395f11..c2baedbcb0fe83a157b3d86fe9d9eddbd056dfbd 100644
--- "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"
@@ -7,13 +7,15 @@
 这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。   
 请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
 
+以下错误的一项是？
 
 ## aop
 
 ### before
 
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 
 ### after
@@ -25,7 +27,37 @@
 ## 答案
 
 ```cpp
-
+int main()
+{
+    int a[15] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, 2, 2, 2};
+
+    int n = 0;
+    do
+    {
+        int sum = 2;
+
+        for (int i = 0; i < 15; i++)
+        {
+            if (a[i] == -1)
+            {
+                sum += a[i];
+            }
+            else
+            {
+                sum *= a[i];
+            }
+        }
+
+        if (a[14] == -1)
+        {
+            n += 1;
+        }
+
+    } while (next_permutation(a, a + 15));
+
+    cout << n << endl;
+    return 0;
+}
 ```
 
 ## 选项
@@ -33,17 +65,87 @@
 ### A
 
 ```cpp
-
+int res = 0;
+
+void f(int dian, int hua, int jiu)
+{
+    if (dian == 0 && hua == 0 && jiu == 1)
+    {
+        res++;
+    }
+    if (dian > 0)
+        f(dian - 1, hua, jiu * 2);
+    if (hua > 0)
+        f(dian, hua - 1, jiu - 1);
+}
+
+int main(int argc, char **argv)
+{
+
+    f(5, 9, 2);
+    cout << res << endl;
+    return 0;
+}
 ```
 
 ### B
 
 ```cpp
-
+int main()
+{
+    int ans = 0;
+    for (int i = 0; i < (1 << 14); ++i)
+    {
+        int tot_1 = 0;
+        int tot_0 = 0;
+        int num = 2;
+        for (int j = 0; j < 14; ++j)
+        {
+            if (i & (1 << j))
+            {
+                tot_1++;
+                num = num * 2;
+            }
+            else
+            {
+                tot_0++;
+                num = num - 1;
+            }
+        }
+        if (tot_1 == 5 && tot_0 == 9 && num == 1)
+        {
+            ++ans;
+        }
+    }
+    cout << ans;
+}
 ```
 
 ### C
 
 ```cpp
-
+int cnt;
+
+void dfs(int a, int b, int sum, int u, int flag)
+{
+    if (u == 15)
+    {
+        if (a == 5 && b == 10 && sum == 0 && flag == 0)
+        {
+            cnt++;
+            return;
+        }
+    }
+    else
+    {
+        dfs(a + 1, b, sum * 2, u + 1, 1);
+        dfs(a, b + 1, sum - 1, u + 1, 0);
+    }
+}
+int main()
+{
+    dfs(0, 0, 2, 0, 0);
+    cout << cnt;
+    return 0;
+}
 ```
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"
index 42838cde1036d565171731d0508a7e37aab8f770..536fdb3dfc0b7c4809983282170b1265b54761a9 100644
--- "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"
@@ -46,6 +46,76 @@
 10000001100111010111010001000110111010101101111000
 ```
 
+下面的程序实现了这一功能，请你补全空白处：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+char mp[55][55];
+int book[55][55];
+int block[55][55];
+int minns[55][55];
+int minn = 100000;
+int dx[4] = {1, 0, 0, -1};
+int dy[4] = {0, -1, 1, 0};
+char dir[4] = {'D', 'L', 'R', 'U'};
+char road[1000];
+char roadans[1000];
+int step;
+
+void dfs(int x, int y, int step)
+{
+    if (x == 29 && y == 49)
+    {
+        if (step < minn)
+        {
+            minn = step;
+            for (int i = 0; i < minn; i++)
+                roadans[i] = road[i];
+        }
+        return;
+    }
+
+    for (int i = 0; i < 4; i++)
+    {
+        int tx = x + dx[i];
+        int ty = y + dy[i];
+        if (tx >= 0 && tx < 30 && ty >= 0 && ty < 50 && book[tx][ty] == 0 && block[tx][ty] == 0 && step + 1 < minns[tx][ty])
+        {
+            book[tx][ty] = 1;
+            road[step] = dir[i];
+            minns[tx][ty] = step + 1;
+            __________________
+            book[tx][ty] = 0;
+        }
+    }
+    return;
+}
+
+int main()
+{
+    for (int i = 0; i < 30; i++)
+    {
+        for (int j = 0; j < 50; j++)
+        {
+            char c;
+            cin >> c;
+            mp[i][j] = c;
+            minns[i][j] = 10000;
+            if (c == '1')
+                block[i][j] = 1;
+        }
+    }
+    book[0][0] = 1;
+    dfs(0, 0, 0);
+    for (int i = 0; i < minn; i++)
+        cout << roadans[i];
+
+    return 0;
+}
+```
+
 ## aop
 
 ### before
@@ -63,7 +133,7 @@
 ## 答案
 
 ```cpp
-
+            dfs(tx, ty, step + 1);
 ```
 
 ## 选项
@@ -71,17 +141,17 @@
 ### A
 
 ```cpp
-
+            dfs(tx, ty, step);
 ```
 
 ### B
 
 ```cpp
-
+            dfs(tx + 1, ty + 1, step + 1);
 ```
 
 ### C
 
 ```cpp
-
+            dfs(tx - 1, ty - 1, step + 1);
 ```
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"
index 6f52a4d03e2ef276bcb180b59afa8a3d041f1af9..047e6d57f56c6a4089f4ab032ee09ebde5b8436a 100644
--- "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"
@@ -22,7 +22,7 @@
 ## 答案
 
 ```cpp
-
+1025
 ```
 
 ## 选项
@@ -30,17 +30,17 @@
 ### A
 
 ```cpp
-
+1024
 ```
 
 ### B
 
 ```cpp
-
+512
 ```
 
 ### C
 
 ```cpp
-
+513
 ```
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"
index efe639c7f2b1d645010379ea750fd38597b2ba4d..eea3430fd3658f25887983115ab0238aa7d67e64 100644
--- "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"
@@ -3,6 +3,37 @@
 两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。   
 比如，11/13=6=>0.846153846153….. 其循环节为[846153] 共有6位。   
 下面的方法，可以求出循环节的长度。  
+请你填补空白处的内容：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+int f(int n, int m)
+{
+    n = n % m;
+    vector<int> v;
+    for (;;)
+    {
+        v.push_back(n);
+        n *= 10;
+        n = n % m;
+        if (n == 0)
+            return 0;
+        if (find(v.begin(), v.end(), n) != v.end())
+        {
+            __________________
+        }
+    }
+}
+int main()
+{
+    int n, m;
+    cin >> n >> m;
+    cout << f(n, m) << endl;
+    return 0;
+}
+```
 
 ## aop
 
@@ -21,7 +52,7 @@
 ## 答案
 
 ```cpp
-
+return v.size() - (find(v.begin(), v.end(), n) - v.begin());
 ```
 
 ## 选项
@@ -29,17 +60,17 @@
 ### A
 
 ```cpp
-
+return v.size() - (find(v.begin(), v.end(), n) + v.begin());
 ```
 
 ### B
 
 ```cpp
-
+return v.size() + (find(v.begin(), v.end(), n) - v.begin());
 ```
 
 ### C
 
 ```cpp
-
+return v.size() - find(v.begin(), v.end(), n) - v.begin();
 ```
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"
index 69988b7067354eda5ef6081f26abfa052e1e5d6e..4acf360a284ea7b8055a0b739769978b648128fd 100644
--- "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"
@@ -56,6 +56,45 @@ ts id
 3
 ```
 
+下面的程序实现了这一功能，请你补全空白处的内容：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+const int N = 1e5 + 10;
+typedef pair<int, int> PII;
+#define x first
+#define y second
+PII logs[N];
+bool st[N];
+int cnt[N];
+
+int main()
+{
+    int n, d, k;
+    cin >> n >> d >> k;
+    for (int i = 0; i < n; i++)
+        cin >> logs[i].x >> logs[i].y;
+
+    sort(logs, logs + n);
+
+    for (int i = 0, j = 0; i < n; i++)
+    {
+        cnt[logs[i].y]++;
+        while (logs[i].x - logs[j].x >= d)
+            __________________
+        if (cnt[logs[i].y] >= k)
+            st[logs[i].y] = true;
+    }
+
+    for (int i = 0; i < N; i++)
+        if (st[i])
+            cout << i << endl;
+    return 0;
+}
+```
+
 ## aop
 
 ### before
@@ -73,7 +112,7 @@ ts id
 ## 答案
 
 ```cpp
-
+cnt[logs[j].y]--, j++;
 ```
 
 ## 选项
@@ -81,17 +120,17 @@ ts id
 ### A
 
 ```cpp
-
+cnt[logs[j].y]--; j++;
 ```
 
 ### B
 
 ```cpp
-
+cnt[logs[j].y]++, j++;
 ```
 
 ### C
 
 ```cpp
-
+cnt[logs[j].y]++; j++;
 ```
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"
index 25778b20fe578f28ded1f687880c1803e03ad2d1..fef83732fa7141312e38c97f9d4e8369f11b1d9b 100644
--- "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"
@@ -12,12 +12,15 @@
 
 ![](https://img-blog.csdnimg.cn/20200530104930106.png)
 
+以下选项错误的是？
+
 ## aop
 
 ### before
 
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 
 ### after
@@ -29,7 +32,88 @@
 ## 答案
 
 ```cpp
+const int MAXN = 1e7;
+
+int arr[9] = {4, 3, 2, 1, 0, 8, 7, 6, 5};
+
+int tar[9] = {5, 6, 7, 8, 0, 1, 2, 3, 4};
+
+int que[MAXN][9];
+
+int dist[MAXN];
+
+int pos[MAXN];
+
+struct cmp
+{
+    bool operator()(int a, int b)
+    {
+        return memcmp(que[a], que[b], sizeof(int) * 9) < 0;
+    }
+};
+
+set<int, cmp> vis;
+
+void set_init()
+{
+    vis.clear();
+}
+
+bool inset_check(int a)
+{
+    if (vis.find(a) == vis.end())
+    {
+        vis.insert(a);
+        return true;
+    }
+    return false;
+}
+
+int bfs()
+{
+
+    int front = 1;
+    int rear = 2;
+    pos[front] = 4;
+    dist[front] = 0;
+    memcpy(que[front], arr, sizeof(int) * 9);
+
+    while (front < rear)
+    {
+        int *a = que[front];
 
+        if (memcmp(a, tar, sizeof(int) * 9) == 0)
+            return front;
+
+        for (int i = -2; i <= 2; i++)
+        {
+            if (i == 0)
+                continue;
+
+            int new_pos = (pos[front] + i + 9) % 9;
+            int *t = que[rear];
+            memcpy(t, a, sizeof(int) * 9);
+            dist[rear] = dist[front];
+
+            t[new_pos] = a[pos[front]];
+            t[pos[front]] = a[new_pos];
+            pos[rear] = new_pos;
+
+            if (inset_check(rear))
+                rear++;
+        }
+        front++;
+    }
+    return 0;
+}
+
+int main()
+{
+    int ans = bfs();
+    printf("%d\n", dist[ans]);
+
+    return 0;
+}
 ```
 
 ## 选项
@@ -37,17 +121,139 @@
 ### A
 
 ```cpp
-
+string start = "012345678";
+string e = "087654321";
+int main()
+{
+    queue<pair<string, int>> q;
+    q.push(make_pair(start, 0));
+    set<string> s;
+    s.insert(start);
+    while (!q.empty())
+    {
+        string a = q.front().first;
+        int level = q.front().second;
+        if (a == e)
+        {
+            cout << level;
+            break;
+        }
+        q.pop();
+        int pos = 0;
+        while (a[pos] != '0')
+            pos++;
+        int posi[4];
+        posi[0] = (pos + 8) % 9;
+        posi[1] = (pos + 1) % 9;
+        posi[2] = (pos + 7) % 9;
+        posi[3] = (pos + 2) % 9;
+        for (int i = 0; i < 4; i++)
+        {
+            string b = a;
+            b[pos] = b[posi[i]];
+            b[posi[i]] = '0';
+            if (s.count(b) == 0)
+            {
+                s.insert(b);
+                q.push(make_pair(b, level + 1));
+            }
+        }
+    }
+    return 0;
+}
 ```
 
 ### B
 
 ```cpp
+struct node
+{
+    string str;
+    int pos;
+    int step;
+    node(string str, int pos, int step) : str(str), pos(pos), step(step) {}
+};
+int N = 9;
+set<string> visited;
+queue<node> q;
+void insertq(node no, int i)
+{
+    string s = no.str;
+    swap(s[no.pos], s[(no.pos + i + 9) % 9]);
 
+    if (visited.count(s) == 0)
+    {
+        visited.insert(s);
+        node n(s, (no.pos + i + 9) % 9, no.step + 1);
+        q.push(n);
+    }
+}
+int main()
+{
+    node first("012345678", 0, 0);
+    q.push(first);
+
+    while (!q.empty())
+    {
+        node temp = q.front();
+        if (temp.str == "087654321")
+        {
+            cout << temp.step;
+            break;
+        }
+        else
+        {
+
+            insertq(temp, 1);
+            insertq(temp, -1);
+            insertq(temp, 2);
+            insertq(temp, -2);
+            q.pop();
+        }
+    }
+}
 ```
 
 ### C
 
 ```cpp
+int dir[] = {1, -1, 2, -2};
+unordered_map<string, int> dist;
+string S = "12345678X", T = "87654321X";
+
+int bfs()
+{
+    queue<string> q;
+    q.push(S);
+    dist[S] = 0;
+
+    while (q.size())
+    {
+        string t = q.front();
+        q.pop();
+
+        if (t == T)
+            return dist[t];
+
+        int k = t.find('X'), distance = dist[t];
+        for (int i = 0; i < 4; i++)
+        {
+            swap(t[k], t[(k + dir[i] + 9) % 9]);
+            if (!dist.count(t))
+            {
+                q.push(t);
+                dist[t] = distance + 1;
+            }
+            swap(t[k], t[(k + dir[i] + 9) % 9]);
+        }
+    }
+
+    return -1;
+}
 
+int main()
+{
+    cout << bfs() << endl;
+    return 0;
+}
 ```
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"
index 62b33e066ea59666f2a12398be8e5d4e98cad4f8..d554d5cbaeceb6057b7c26aef42a9e0ce020d1f8 100644
--- "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"
@@ -48,12 +48,15 @@ This is a story about Alice and Bob. Alice wants to send a private message to Bo
 2
 ```
 
+以下选项错误的是？
+
 ## aop
 
 ### before
 
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 
 ### after
@@ -65,7 +68,72 @@ This is a story about Alice and Bob. Alice wants to send a private message to Bo
 ## 答案
 
 ```cpp
-
+int main()
+{
+    int k;
+    scanf("%d", &k);
+    getchar();
+
+    const char *a = "Alice", *b = "Bob";
+    char str[1000000];
+    gets(str);
+
+    int length = strlen(str);
+    int num = 0, i, j, t, flag;
+    char word[20];
+    for (i = 0; i < length; i++)
+    {
+        if (str[i] == 'A' || str[i] == 'B')
+        {
+            j = 0;
+            while (str[i] != ' ' && str[i] != '.')
+                word[j++] = str[i++];
+            word[j] = '\0';
+
+            flag = 0;
+            if (strcmp(word, a) == 0)
+                flag = 1;
+            else if (strcmp(word, b) == 0)
+                flag = 2;
+
+            if (flag == 1)
+            {
+                for (t = i; t < length; t++)
+                {
+                    if (str[t] == 'B')
+                    {
+                        j = 0;
+                        while (str[t] != ' ' && str[t] != '.')
+                            word[j++] = str[t++];
+                        word[j] = '\0';
+
+                        if (strcmp(word, b) == 0)
+                            num++;
+                    }
+                }
+            }
+            else if (flag == 2)
+            {
+                for (t = i; t < length; t++)
+                {
+                    if (str[t] == 'A')
+                    {
+                        j = 0;
+                        while (str[t] != ' ' && str[t] != '.')
+                            word[j++] = str[t++];
+                        word[j] = '\0';
+
+                        if (strcmp(word, a) == 0)
+                            num++;
+                    }
+                }
+            }
+        }
+    }
+    printf("%d\n", num);
+
+    return 0;
+}
 ```
 
 ## 选项
@@ -73,17 +141,171 @@ This is a story about Alice and Bob. Alice wants to send a private message to Bo
 ### A
 
 ```cpp
-
+int cnt, k;
+bool temp = true;
+char f[2][20] = {"Alice", "Bob"};
+bool check(string &a, int &pa, int &pb)
+{
+    bool flage = true;
+    pa = a.find(f[0], ++pa);
+    if (pa == -1)
+        temp = false;
+    if (temp && abs((pa - 1) - pb) < k && pb)
+        cnt++;
+    if (a[pa - 1] != ' ' && a[pa + 6] != ' ')
+        flage = false;
+    pb = a.find(f[1], ++pb);
+    if (pb == -1)
+        temp = false;
+    if (a[pb - 1] != ' ' && a[pb + 6] != ' ')
+        flage = false;
+    return flage;
+}
+int main()
+{
+    string a;
+    cin >> k;
+    getchar();
+    getline(cin, a);
+    int pa = 0, pb = 0;
+    while (1)
+    {
+        if (check(a, pa, pb) && abs(pa - pb) < k && temp)
+        {
+            cnt++;
+        }
+        else if (!temp)
+            break;
+    }
+    cout << cnt;
+    return 0;
+}
 ```
 
 ### B
 
 ```cpp
-
+#define mem(a, b) memset(a, b, sizeof a)
+#define PII pair<int, int>
+#define ll long long
+#define ull unsigned long long
+#define IOS ios::sync_with_stdio(0), cin.tie(0)
+#define gcd(a, b) __gcd(a, b)
+#define ft first
+#define sd second
+#define endl '\n'
+#define PI acos(-1.0)
+#define lcm(a, b) a / gcd(a, b) * b
+#define INF_INT 0x3f3f3f3f
+#define INF_LONG 4557430888798830399
+const int N = 4e6 + 9;
+int ta, tb;
+int a[N], b[N];
+string s;
+int solve(string ss, int *cnt)
+{
+    int t = 0, n = s.size();
+    for (int i = 0; i < n; i++)
+    {
+        if (s[i] == ss[0])
+        {
+            if (i)
+            {
+                char ch = s[i - 1];
+                if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
+                    continue;
+            }
+            int flag = 1, j;
+            string tmp = "";
+            for (j = i; j < n && j - i < ss.size(); j++)
+            {
+                tmp += s[j];
+            }
+            if (tmp != ss)
+                flag = 0;
+
+            if (j < n && ((s[j] >= 'a' && s[j] <= 'z') || (s[j] >= 'A' && s[j] <= 'Z')))
+                flag = 0;
+            if (flag)
+                cnt[t++] = i;
+        }
+    }
+    return t;
+}
+int main()
+{
+    int k;
+    cin >> k;
+    getchar();
+    getline(cin, s);
+    int ta = solve("Alice", a);
+    int tb = solve("Bob", b);
+    ll ans = 0;
+    for (int i = 0, lp = 0, rp = 0; i < ta; i++)
+    {
+        while (b[lp] < a[i] - 3 - k)
+            lp++;
+        while (b[rp] <= a[i] + k + 5 && rp < tb)
+            rp++;
+
+        if (rp - lp > 0)
+            ans += (ll)(rp - lp);
+    }
+    cout << ans << endl;
+    return 0;
+}
 ```
 
 ### C
 
 ```cpp
-
+int len;
+string s;
+bool check(int i)
+{
+    if (len - i < 5)
+        return false;
+    return s[i + 1] == 'l' && s[i + 2] == 'i' && s[i + 3] == 'c' && s[i + 4] == 'e';
+}
+bool check2(int i)
+{
+    if (len - i < 3)
+        return false;
+    return s[i + 1] == 'o' && s[i + 2] == 'b';
+}
+int main()
+{
+    int k;
+    cin >> k;
+    getchar();
+    getline(cin, s);
+    len = s.length();
+    vector<int> Alice, Bob;
+    for (int i = 0; i < len; i++)
+    {
+        if (s[i] == 'A' && check(i))
+        {
+            Alice.push_back(i);
+            i += 5;
+        }
+        else if (s[i] == 'B' && check2(i))
+        {
+            Bob.push_back(i);
+            i += 3;
+        }
+    }
+    int As = Alice.size(), Bs = Bob.size();
+    int i = 0, j = 0;
+    long long ans = 0;
+    for (int q = 0; q < As; q++)
+    {
+        while (i < Bs && Bob[i] < Alice[q] - k - 3)
+            i++;
+        while (j < Bs && Bob[j] <= Alice[q] + k + 5)
+            j++;
+        ans += j - i;
+    }
+    cout << ans << "\n";
+    return 0;
+}
 ```
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"
index 0edc91efff82fa26af356c278d4becdc64444d81..ad7f1779968ea70f28a78c47c61612644bd368cc 100644
--- "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"
@@ -23,7 +23,7 @@
 ## 答案
 
 ```cpp
-
+2017-08-05
 ```
 
 ## 选项
@@ -31,17 +31,17 @@
 ### A
 
 ```cpp
-
+2017-09-05
 ```
 
 ### B
 
 ```cpp
-
+2017-08-06
 ```
 
 ### C
 
 ```cpp
-
+2017-09-06
 ```
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"
index 98454f14ee11b190007e38da18b9327a55da9299..81d69dc937ebc13e9cfdae6d7063d381b98145c9 100644
--- "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"
@@ -10,6 +10,7 @@
 都符合要求。  
 如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。
 
+以下选项错误的是？
 
 ## aop
 
@@ -28,7 +29,57 @@
 ## 答案
 
 ```cpp
+int vis[10];
+int ans = 0;
+bool s(int i)
+{
+    while (i)
+    {
+        if (vis[i % 10] == 1)
+            return false;
+        else
+        {
+            vis[i % 10] = 1;
+            i /= 10;
+        }
+    }
+    return true;
+}
+int main()
+{
+    for (int i = 1; i < 999; i++)
+    {
+        for (int j = 1; j < 999; j++)
+        {
+            memset(vis, 0, sizeof(vis));
+            if (s(i) && s(j))
+            {
+                int k = i * j;
+                if (k > 9999 || k < 1000)
+                    continue;
 
+                int t = k;
+                while (k)
+                {
+                    if (vis[k % 10] == 1)
+                    {
+                        vis[k % 10]++;
+
+                        k /= 10;
+                    }
+                    else
+                        break;
+                }
+                if (k == 0 && vis[0] != 1 && vis[1] != 1 && vis[2] != 1 && vis[3] != 1 && vis[4] != 1 && vis[5] != 1 && vis[6] != 1 && vis[7] != 1 && vis[8] != 1 && vis[9] != 1)
+                {
+                    ans++;
+                }
+            }
+        }
+    }
+    cout << ans << endl;
+    return 0;
+}
 ```
 
 ## 选项
@@ -36,17 +87,209 @@
 ### A
 
 ```cpp
+bool isOk(int result, int t1, int t2)
+{
+    bool flag1[10] = {0}, flag2[10] = {0};
+    int i, rNum[4], num[4];
+    for (i = 0; i < 4; i++)
+    {
+        rNum[i] = result % 10;
+        result /= 10;
+        if (flag1[rNum[i]])
+            return false;
+        flag1[rNum[i]] = true;
+    }
+    i = 0;
+    while (t1 > 0)
+    {
+        num[i] = t1 % 10;
+        t1 /= 10;
+        if (flag2[num[i]])
+            return false;
+        flag2[num[i]] = true;
+        i++;
+    }
+    while (t2 > 0)
+    {
+        num[i] = t2 % 10;
+        t2 /= 10;
+        if (flag2[num[i]])
+            return false;
+        flag2[num[i]] = true;
+        i++;
+    }
+    if (i != 4)
+        return false;
+    for (i = 0; i < 10; i++)
+        if (flag1[i] != flag2[i])
+            return false;
+    return true;
+}
+
+int main()
+{
+    int i, j, count = 0;
+    for (i = 1000; i < 10000; i++)
+    {
 
+        for (j = 1; j * j <= i; j++)
+            if (!(i % j) && isOk(i, j, i / j))
+            {
+                count++;
+            }
+    }
+    cout << count << endl;
+
+    return 0;
+}
 ```
 
 ### B
 
 ```cpp
-
+int main()
+{
+    int v[5], i;
+    int ans = 0;
+    for (i = 1023; i <= 9876; i++)
+    {
+        v[0] = i / 1000;
+        v[1] = i / 10 % 10;
+        v[2] = i / 100 % 10;
+        v[3] = i % 10;
+        int flag1 = 0, flag2 = 0;
+        if (v[0] != v[1] && v[0] != v[2] && v[0] != v[3] && v[1] != v[2] && v[1] != v[3] && v[2] != v[3])
+        {
+            do
+            {
+                if (flag1 != 3 && (v[0] * 100 + v[1] * 10 + v[2]) * v[3] == i)
+                {
+                    flag1 = 1;
+                    ans++;
+                }
+                else if (flag2 != 2 && (v[0] * 10 + v[1]) * (v[2] * 10 + v[3]) == i)
+                {
+                    flag2 = 2;
+                    ans++;
+                }
+                else if (flag1 != 1 && v[0] * (v[1] * 100 + v[2] * 10 + v[3]) == i)
+                {
+                    flag1 = 3;
+                    ans++;
+                }
+            } while (next_permutation(v, v + 4));
+        }
+    }
+    cout << ans;
+    return 0;
+}
 ```
 
 ### C
 
 ```cpp
+#define MAX_N 1005
+
+bool judge1(int n)
+{
+    int ans = 0;
+    while (n)
+    {
+        ans++;
+        n /= 10;
+    }
+    if (ans == 4)
+        return true;
+    return false;
+}
+
+bool judge2(int i, int j)
+{
+    int s1 = 0, s2 = 0;
+    int ss1 = 1, ss2 = 1;
+    int tmp = i * j;
+    bool flag1 = true, flag2 = true;
+    while (tmp)
+    {
+        s1 += tmp % 10;
+        if (tmp % 10 == 0)
+            flag1 = false;
+        else
+            ss1 *= tmp % 10;
+        tmp /= 10;
+    }
+    while (j)
+    {
+        s2 += j % 10;
+        if (j % 10 != 0)
+            ss2 *= j % 10;
+        else
+            flag2 = false;
+        j /= 10;
+    }
+    while (i)
+    {
+        s2 += i % 10;
+        if (i % 10 != 0)
+            ss2 *= i % 10;
+        else
+            flag2 = false;
+        i /= 10;
+    }
+    if (s1 == s2 && ss1 == ss2 && flag1 && flag2)
+        return true;
+    else if ((!flag1 && !flag2) && s1 == s2 && ss1 == ss2)
+        return true;
+    return false;
+}
+
+bool judge3(int i, int j)
+{
+    int a[4];
+    int ans = 0;
+    while (i)
+    {
+        a[ans] = i % 10;
+        i /= 10;
+        ans++;
+    }
+    while (j)
+    {
+        a[ans] = j % 10;
+        j /= 10;
+        ans++;
+    }
+    for (i = 0; i < 3; i++)
+    {
+        for (j = i + 1; j < 4; j++)
+            if (a[i] == a[j])
+                return false;
+    }
+    return true;
+}
+
+int main()
+{
 
+    int i, j;
+    int ans = 0;
+    for (i = 1; i < 10; i++)
+    {
+        for (j = 123; j < 1000; j++)
+        {
+            if (judge1(i * j) && judge2(i, j) && judge3(i, j))
+                ans++;
+        }
+    }
+    for (i = 10; i < 100; i++)
+    {
+        for (j = i + 1; j < 100; j++)
+        {
+            if (judge1(i * j) && judge2(i, j) && judge3(i, j))
+                ans++;
+        }
+    }
+    cout << ans;
+    return 0;
+}
 ```
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"
index 81b216b3b6bb3793798c6f967b3a5c2cd8e824f1..396b4515bd07474d21beaf63fb9e1e390c690725 100644
--- "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"
@@ -33,6 +33,41 @@ HHHellllloo
 
 请注意原来的串长度可能超过 100。
 
+以下程序实现了这一功能，请你填补空白处内容：
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+char s2[100000];
+int main()
+{
+    char s1[150];
+    cin >> s1;
+
+    int top = 0;
+    for (int i = 0; s1[i] != '\0'; i++)
+    {
+        if ((s1[i] >= 'A' && s1[i] <= 'Z') || (s1[i] >= 'a' && s1[i] <= 'z'))
+        {
+            s2[top++] = s1[i];
+        }
+        else
+        {
+            while (s1[i] != '1')
+            {
+                __________________
+                s1[i] = s1[i] - 1;
+            }
+        }
+    }
+    s2[top] = '\0';
+
+    cout << s2;
+    return 0;
+}
+```
+
 ## aop
 
 ### before
@@ -50,7 +85,7 @@ HHHellllloo
 ## 答案
 
 ```cpp
-
+s2[top++] = s1[i - 1];
 ```
 
 ## 选项
@@ -58,17 +93,17 @@ HHHellllloo
 ### A
 
 ```cpp
-
+s2[++top] = s1[i - 1];
 ```
 
 ### B
 
 ```cpp
-
+s2[++top] = s1[i + 1];
 ```
 
 ### C
 
 ```cpp
-
+s2[top++] = s1[i + 1];
 ```
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"
index 4500ff48cf1f90b231138ca379247f05f2bc7dfe..23e068e223fa556ccb60e22c54ee4f1cd88402f9 100644
--- "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"
@@ -19,7 +19,7 @@
 ## 答案
 
 ```cpp
-
+5217
 ```
 
 ## 选项
@@ -27,17 +27,17 @@
 ### A
 
 ```cpp
-
+5218
 ```
 
 ### B
 
 ```cpp
-
+5216
 ```
 
 ### C
 
 ```cpp
-
+5210
 ```
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"
index db72f3c0037e0399498cd7dc6196118239409cfe..00767554e3615620e92e4c5ed112bb9d7974a35e 100644
--- "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"
@@ -53,13 +53,15 @@
 对于所有评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ t ≤ 100。
 ```
 
+以下选项错误的是？
 
 ## aop
 
 ### before
 
 ```cpp
-
+#include <bits/stdc++.h>
+using namespace std;
 ```
 
 ### after
@@ -71,7 +73,98 @@
 ## 答案
 
 ```cpp
-
+int main()
+{
+    int n = 0;
+    int m = 0;
+    cin >> n;
+    cin >> m;
+    int ar[n + 1][n + 1];
+
+    for (int i = 0; i < n + 1; i++)
+        for (int j = 0; j < n + 1; j++)
+            ar[i][j] = 0;
+
+    bool arJudge[n + 1];
+
+    for (int i = 0; i < n + 1; i++)
+        arJudge[i] = 0;
+
+    vector<int> v(n, 0);
+    for (int i = 0; i <= n; ++i)
+    {
+        for (int j = 0; j <= n; ++j)
+        {
+            ar[i][j] = 0;
+        }
+    }
+
+    int a = 0, b = 0, c = 0;
+    for (int i = 0; i < m; ++i)
+    {
+        cin >> a;
+        cin >> b;
+        cin >> c;
+        if (a == 1)
+        {
+            if (ar[b][c] == 0)
+            {
+                ar[b][c] = 1;
+            }
+
+            if (ar[c][b] == 0)
+            {
+                ar[c][b] = 1;
+            }
+        }
+        if (a == 2)
+        {
+            queue<int> que;
+            que.push(b);
+            while (!que.empty())
+            {
+                int size = que.size();
+
+                for (int i = 0; i < size; ++i)
+                {
+                    int temp = que.front();
+                    que.pop();
+                    if (arJudge[temp] == 0)
+                    {
+                        v[temp - 1] += c;
+                        arJudge[temp] = 1;
+                    }
+                    for (int j = 1; j <= n; ++j)
+                    {
+                        if (ar[temp][j] != 0)
+                        {
+                            que.push(j);
+                        }
+                    }
+                }
+            }
+        }
+        for (int i = 0; i <= n; ++i)
+        {
+            arJudge[i] = 0;
+        }
+    }
+
+    for (int i = 1; i <= n; ++i)
+    {
+        for (int j = 1; j <= n; ++j)
+        {
+            cout << ar[i][j] << " ";
+        }
+        cout << endl;
+    }
+    for (int i = 0; i < n; ++i)
+    {
+        cout << v[i] << " ";
+    }
+    cout << endl;
+    return 0;
+}
 ```
 
 ## 选项
@@ -79,17 +172,184 @@
 ### A
 
 ```cpp
-
+int const N = 10010;
+using namespace std;
+int n, m;
+int i, j, k;
+int num[N];
+
+int f[N];
+
+int r[N];
+
+void init()
+{
+    for (i = 1; i <= n; i++)
+    {
+        f[i] = i;
+        r[i] = 1;
+    }
+}
+
+int find(int x)
+{
+    return f[x] == x ? x : (f[x] = find(f[x]));
+}
+
+void send(int x, int y)
+{
+    int tempx, tempy;
+
+    tempx = find(x);
+    tempy = find(y);
+    if (r[tempx] >= r[tempy])
+    {
+
+        f[tempy] = tempx;
+    }
+    else
+    {
+        f[tempx] = tempy;
+    }
+    if (r[tempx] == r[tempy] && tempx != tempy)
+    {
+        r[tempx]++;
+    }
+}
+void count(int x, int y)
+{
+    int tempx;
+    tempx = find(x);
+    for (i = 1; i <= n; i++)
+    {
+        if (tempx == find(i))
+        {
+            num[i] += y;
+        }
+    }
+}
+int main()
+{
+    cin >> n >> m;
+    init();
+    while (m--)
+    {
+        int x, y, z;
+        cin >> x >> y >> z;
+        if (x == 1)
+        {
+            send(y, z);
+        }
+        if (x == 2)
+        {
+            count(y, z);
+        }
+    }
+    for (i = 1; i <= n; i++)
+    {
+        cout << num[i] << " ";
+    }
+    return 0;
+}
 ```
 
 ### B
 
 ```cpp
-
+const int N = 10010;
+int p[N], d[N];
+int find(int x)
+{
+    if (p[x] == x || p[p[x]] == p[x])
+        return p[x];
+    int r = find(p[x]);
+    d[x] += d[p[x]];
+    p[x] = r;
+    return r;
+}
+int main()
+{
+    int n, m;
+    cin >> n >> m;
+    for (int i = 1; i <= n; i++)
+        p[i] = i;
+    while (m--)
+    {
+        int t, a, b;
+        cin >> t >> a >> b;
+        if (t == 1)
+        {
+            a = find(a), b = find(b);
+            if (a != b)
+            {
+                d[a] -= d[b];
+                p[a] = b;
+            }
+        }
+        else
+        {
+            a = find(a);
+            d[a] += b;
+        }
+    }
+    for (int i = 1; i <= n; i++)
+        if (i == find(i))
+            cout << d[i] << " ";
+        else
+            cout << d[i] + d[find(i)] << " ";
+    cout << endl;
+    return 0;
+}
 ```
 
 ### C
 
 ```cpp
-
+const int maxn = 10005;
+int a[maxn][maxn];
+int dfs_vis[maxn];
+int n, m;
+
+struct Node
+{
+    int data;
+} Point[maxn];
+
+void DFS(int a[maxn][maxn], int x, int y)
+{
+    Point[x].data += y;
+    dfs_vis[x] = 1;
+    for (int i = 1; i <= n; i++)
+    {
+        if (a[x][i] == 1 && dfs_vis[i] == 0)
+        {
+            DFS(a, i, y);
+        }
+    }
+}
+int main()
+{
+    cin >> n >> m;
+    cin.get();
+
+    for (int i = 1; i <= m; i++)
+    {
+        int flag, x1, x2;
+        scanf("%d %d %d", &flag, &x1, &x2);
+        if (flag == 1)
+        {
+            a[x1][x2] = a[x2][x1] = 1;
+        }
+        else if (flag == 2)
+        {
+            memset(dfs_vis, 0, sizeof(dfs_vis));
+            DFS(a, x1, x2);
+        }
+    }
+    for (int i = 1; i <= n; ++i)
+    {
+        cout << Point[i].data << " ";
+    }
+    return 0;
+}
 ```
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"
index 75171c4f7801e6798f4caa832ec4404a2e58dcca..687bb316e211cc07b558223981a2d0cb200063fe 100644
--- "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"
@@ -69,6 +69,8 @@
 对于所有评测用例，1 ≤ k ≤ 108, 1 ≤ t ≤ 105, 1 ≤ n, m ≤ 1018，且 k 是质数。评测时将使用 10 个评测用例测试你的程序
 ```
 
+以下选项错误的是？
+
 ## aop
 
 ### before
@@ -86,7 +88,7 @@
 ## 答案
 
 ```cpp
-
+其他三项都是错的
 ```
 
 ## 选项
@@ -94,17 +96,158 @@
 ### A
 
 ```cpp
-
+const int Mod = 1e9 + 7;
+int c[2010][2010];
+int main()
+{
+    int n, m, t, k;
+    cin >> t >> k;
+    int nn = 2000, mm = 2000;
+    for (int i = 0; i <= nn; i++)
+    {
+        c[i][0] = 1;
+        c[i][i] = 1;
+    }
+    for (int i = 1; i <= nn; i++)
+        for (int j = 1; j <= mm; j++)
+            c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % k;
+    while (t--)
+    {
+        cin >> n >> m;
+        int ans = 0;
+        for (int j = 0; j <= m; j++)
+            for (int i = j; i <= n; i++)
+                if (c[i][j] == 0)
+                    ans++;
+        cout << ans % Mod;
+    }
+    return 0;
+}
 ```
 
 ### B
 
 ```cpp
-
+#define modk(x) (((x) >= k) ? ((x)-k) : (x))
+const int maxn = 2005;
+int c[maxn][maxn], n, m, k, T;
+void init()
+{
+
+    c[0][0] = 1;
+    for (int i = 1; i < maxn; i++)
+    {
+        c[i][0] = 1 % k;
+        for (int j = 1; j <= i; j++)
+        {
+            c[i][j] = modk(c[i - 1][j] + c[i - 1][j - 1]);
+        }
+    }
+
+    for (int i = 0; i < maxn; i++)
+    {
+        for (int j = 0; j <= i; j++)
+        {
+            if (c[i][j] == 0)
+                c[i][j] = 1;
+            else
+                c[i][j] = 0;
+        }
+    }
+
+    for (int i = 1; i < maxn; i++)
+    {
+        int s = 0;
+        for (int j = 0; j < maxn; j++)
+        {
+            s += c[i][j];
+            c[i][j] = c[i - 1][j] + s;
+        }
+    }
+}
+int main()
+{
+    scanf("%d%d", &T, &k);
+    init();
+    while (T--)
+    {
+        scanf("%d%d", &n, &m);
+        printf("%d\n", c[n][m]);
+    }
+    return 0;
+}
 ```
 
 ### C
 
 ```cpp
-
+const int Mod = 1e9 + 7;
+const int inv_2 = 5e8 + 4;
+
+long long cal(long long x, long long y)
+{
+    if (x < y)
+    {
+        x %= Mod;
+        return (x + 2) * (x + 1) % Mod * inv_2 % Mod;
+    }
+    x %= Mod, y %= Mod;
+    return ((y + 2) * (y + 1) % Mod * inv_2 % Mod + (x - y) * (y + 1) % Mod) % Mod;
+}
+long long cal_1(long long x, long long y)
+{
+    return min(x, y) + 1;
+}
+long long cal_2(long long x, long long y)
+{
+    if (x < y)
+    {
+        return 0;
+    }
+    return x - y + 1;
+}
+
+int main()
+{
+    int t, k;
+    cin >> t >> k;
+    long long n, m;
+    int a[100], b[100];
+    for (int turn = 0; turn < t; ++turn)
+    {
+        cin >> n >> m;
+        if (m > n)
+            m = n;
+        long long ans = cal(n, m);
+        int len_a = 0, len_b = 0;
+        while (n)
+        {
+            a[len_a++] = n % k;
+            n /= k;
+        }
+        while (m)
+        {
+            b[len_b++] = m % k;
+            m /= k;
+        }
+        int len = max(len_a, len_b);
+        vector<vector<long long>> dp(len + 1, vector<long long>(4));
+        dp[len][3] = 1;
+        for (int i = len - 1; i >= 0; --i)
+        {
+            dp[i][0] = dp[i + 1][0] * cal(k - 1, k - 1) + dp[i + 1][1] * cal(a[i] - 1, k - 1) + dp[i + 1][2] * cal(k - 1, b[i] - 1) + dp[i + 1][3] * cal(a[i] - 1, b[i] - 1);
+            dp[i][1] = dp[i + 1][1] * cal_1(a[i], k - 1) + dp[i + 1][3] * cal_1(a[i], b[i] - 1);
+            dp[i][2] = dp[i + 1][2] * cal_2(k - 1, b[i]) + dp[i + 1][3] * cal_2(a[i] - 1, b[i]);
+            dp[i][3] = dp[i + 1][3] & (a[i] >= b[i]);
+            dp[i][0] %= Mod, dp[i][1] %= Mod;
+            dp[i][2] %= Mod, dp[i][3] %= Mod;
+        }
+        ans -= dp[0][0] + dp[0][1] + dp[0][2] + dp[0][3];
+        ans %= Mod;
+        if (ans < 0)
+            ans += Mod;
+        cout << ans << endl;
+    }
+    return 0;
+}
 ```
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"
index b5413409599546cea75a5ab611975a98c0bc5ede..d1b09b7821b69336cc4fabfdea55ae3670f15eb7 100644
--- "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"
@@ -20,7 +20,7 @@
 ## 答案
 
 ```cpp
-
+26
 ```
 
 ## 选项
@@ -28,17 +28,17 @@
 ### A
 
 ```cpp
-
+24
 ```
 
 ### B
 
 ```cpp
-
+25
 ```
 
 ### C
 
 ```cpp
-
+27
 ```
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"
index 4169c0a2e1657e8a8dc739bf6a8e74e12640429f..8641aaa2163f0afe8f03e353b41ab924ec231aa2 100644
--- "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"
@@ -22,7 +22,7 @@
 ## 答案
 
 ```cpp
-
+761
 ```
 
 ## 选项
@@ -30,17 +30,17 @@
 ### A
 
 ```cpp
-
+759
 ```
 
 ### B
 
 ```cpp
-
+760
 ```
 
 ### C
 
 ```cpp
-
+769
 ```
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"
index f2dd9dab9d6b9a1cc446bac8c716f23f9be81ccb..1e06357006ffc4a46538ad09865bc2e1fb4cf691 100644
--- "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"
@@ -23,7 +23,7 @@
 ## 答案
 
 ```cpp
-
+3880
 ```
 
 ## 选项
@@ -31,17 +31,17 @@
 ### A
 
 ```cpp
-
+3400
 ```
 
 ### B
 
 ```cpp
-
+3920
 ```
 
 ### C
 
 ```cpp
-
+3900
 ```
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"
index 3a52e4752dca8d5f0c3cf6cf4e6e4c97bc15e5b1..92cdf9cdba8617fdfb5ecb5e9eb2e4c7d157cddf 100644
--- "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"
@@ -2,7 +2,30 @@
 
 求1个整数的第k位数字有很多种方法。
 
-以下的方法就是一种。
+以下的方法就是一种。请你填补空白处的内容：
+
+```cpp
+#include <stdio.h>
+int len(int x)
+{
+    if (x < 10)
+        return 1;
+    return len(x / 10) + 1;
+}
+
+int f(int x, int k)
+{
+    if (len(x) - k == 0)
+        return x % 10;
+    __________________
+}
+int main()
+{
+    int x = 23574;
+    printf("%d\n", f(x, 3));
+    return 0;
+}
+```
 
 
 
@@ -23,7 +46,7 @@
 ## 答案
 
 ```cpp
-
+    return f(x / 10, k);
 ```
 
 ## 选项
@@ -31,17 +54,17 @@
 ### A
 
 ```cpp
-
+    return f(x % 10, k);
 ```
 
 ### B
 
 ```cpp
-
+    return f(x, k);
 ```
 
 ### C
 
 ```cpp
-
+    return f(x, k / 10);
 ```
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"
index e8f04c78f3e8263605e956952c80e5861542cb08..58cd5a2c4e6759cdd60f96a1cbe325af832e9963 100644
--- "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"
@@ -21,7 +21,7 @@
 ## 答案
 
 ```cpp
-
+8879
 ```
 
 ## 选项
@@ -29,17 +29,17 @@
 ### A
 
 ```cpp
-
+8888
 ```
 
 ### B
 
 ```cpp
-
+8880
 ```
 
 ### C
 
 ```cpp
-
+8808
 ```