add exercises

data/1.算法初阶/1.蓝桥杯-基础/20.星系炸弹/config.json

+{
+  "node_id": "algorithm-7155bf0956dc4133abb9ba64b5e4f6ae",
+  "keywords": [
+    "蓝桥杯",
+    "星系炸弹"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/20.星系炸弹/desc.md

+在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。  
+每个炸弹都可以设定多少天之后爆炸。  
+比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。  
+有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。  

data/1.算法初阶/1.蓝桥杯-基础/20.星系炸弹/solution.cpp

+#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

data/1.算法初阶/1.蓝桥杯-基础/20.星系炸弹/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "880abd1a201c4b02b1c3e75a502c8fcc"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/20.星系炸弹/solution.md

+# 星系炸弹
+
+在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
+```

data/1.算法初阶/1.蓝桥杯-基础/21.蛇形填数/config.json

+{
+  "node_id": "algorithm-f4874378183445fb9edcf1cb372399f7",
+  "keywords": [
+    "蓝桥杯",
+    "蛇形填数"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/21.蛇形填数/desc.md

+如下图所示，小明用从1 开始的正整数“蛇形”填充无限大的矩阵。  
+![](https://img-blog.csdnimg.cn/20210221154521571.png)  
+容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20 行第20 列的数是多少？

data/1.算法初阶/1.蓝桥杯-基础/21.蛇形填数/solution.cpp

+#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;
+}

data/1.算法初阶/1.蓝桥杯-基础/21.蛇形填数/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "383bda00ddc5462ab99e42db64e0f076"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/21.蛇形填数/solution.md

+# 蛇形填数
+
+如下图所示，小明用从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
+```

data/1.算法初阶/1.蓝桥杯-基础/22.跑步训练/config.json

+{
+  "node_id": "algorithm-e707e31088ea4929964936a8f8ef15d7",
+  "keywords": [
+    "蓝桥杯",
+    "跑步训练"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/22.跑步训练/desc.md

+小明要做一个跑步训练。  
+初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。    
+小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0 ，他就停止锻炼。  
+请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案

data/1.算法初阶/1.蓝桥杯-基础/22.跑步训练/solution.cpp

+#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

data/1.算法初阶/1.蓝桥杯-基础/22.跑步训练/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "916f0cb3ec744b6a94784acd8f421495"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/22.跑步训练/solution.md

+# 跑步训练
+
+小明要做一个跑步训练。  
+初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。    
+小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0 ，他就停止锻炼。  
+请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案
+
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+3880
+```
+
+## 选项
+
+### A
+
+```cpp
+3400
+```
+
+### B
+
+```cpp
+3920
+```
+
+### C
+
+```cpp
+3900
+```

data/1.算法初阶/1.蓝桥杯-基础/23.特别数的和/config.json

+{
+  "node_id": "algorithm-ef2760aef95742c49f78c313d1ff2eb1",
+  "keywords": [
+    "蓝桥杯",
+    "特别数的和"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/23.特别数的和/desc.md

+#### 题目描述
+小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
+
+请问，在 1 到 n 中，所有这样的数的和是多少？
+
+#### 输入格式
+共一行，包含一个整数 n。
+
+#### 输出格式
+共一行，包含一个整数，表示满足条件的数的和。
+
+#### 数据范围
+```
+1≤n≤10000
+```
+#### 输入样例：
+```
+40
+```
+#### 输出样例：
+```
+574
+```

data/1.算法初阶/1.蓝桥杯-基础/23.特别数的和/solution.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;
+        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;
+}

data/1.算法初阶/1.蓝桥杯-基础/23.特别数的和/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "17de9b97dbc247aba50ec0c5c0170a68"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/23.特别数的和/solution.md

+# 特别数的和
+
+**题目描述**
+
+小明对数位中含有 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;
+```

data/1.算法初阶/1.蓝桥杯-基础/24.切面条/config.json

+{
+  "node_id": "algorithm-530255df51be437b967cbc4524fe66ea",
+  "keywords": [
+    "蓝桥杯",
+    "切面条"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/24.切面条/desc.md

+一根高筋拉面，中间切一刀，可以得到2根面条。  
+如果先对折1次，中间切一刀，可以得到3根面条。  
+如果连续对折2次，中间切一刀，可以得到5根面条。  
+那么，连续对折10次，中间切一刀，会得到多少面条呢？      
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/24.切面条/solution.cpp

+#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];
+}

data/1.算法初阶/1.蓝桥杯-基础/24.切面条/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "096fc08eabd34865aa1a97820435d66b"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/24.切面条/solution.md

+# 切面条
+
+一根高筋拉面，中间切一刀，可以得到2根面条。  
+如果先对折1次，中间切一刀，可以得到3根面条。  
+如果连续对折2次，中间切一刀，可以得到5根面条。  
+那么，连续对折10次，中间切一刀，会得到多少面条呢？      
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+1025
+```
+
+## 选项
+
+### A
+
+```cpp
+1024
+```
+
+### B
+
+```cpp
+512
+```
+
+### C
+
+```cpp
+513
+```

data/1.算法初阶/1.蓝桥杯-基础/25.日志统计/config.json

+{
+  "node_id": "algorithm-9aea8ae61f274180b9b7172c43ebe69f",
+  "keywords": [
+    "蓝桥杯",
+    "日志统计"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/25.日志统计/desc.md

+#### 题目描述
+小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 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

data/1.算法初阶/1.蓝桥杯-基础/25.日志统计/solution.cpp

+#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;
+}

data/1.算法初阶/1.蓝桥杯-基础/25.日志统计/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "55585dfb13104063adb7e4d41384f5a6"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/25.日志统计/solution.md

+# 日志统计
+
+**题目描述**
+
+小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 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++;
+```

data/1.算法初阶/1.蓝桥杯-基础/26.神奇算式/config.json

+{
+  "node_id": "algorithm-d98c791357f2416389a36896d0186317",
+  "keywords": [
+    "蓝桥杯",
+    "神奇算式"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/26.神奇算式/desc.md

+由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。
+比如： 
+```
+210 x 6 = 1260 
+8 x 473 = 3784
+27 x 81 = 2187 
+```
+都符合要求。  
+如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。

data/1.算法初阶/1.蓝桥杯-基础/26.神奇算式/solution.cpp

+#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;
+}

data/1.算法初阶/1.蓝桥杯-基础/26.神奇算式/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "aad0e280f4944ea9aff2b9e426aaef21"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/26.神奇算式/solution.md

+# 神奇算式
+
+由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;
+}
+```

data/1.算法初阶/1.蓝桥杯-基础/27.星期一/config.json

+{
+  "node_id": "algorithm-b788a09cd8e647738a9ac6aea903aadb",
+  "keywords": [
+    "蓝桥杯",
+    "星期一"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/27.星期一/desc.md

+整个20世纪（1901年1月1日至2000年12月31日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/27.星期一/solution.cpp

+#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;
+}

data/1.算法初阶/1.蓝桥杯-基础/27.星期一/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "d246625d4b1140b3a726569ae37220fb"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/27.星期一/solution.md

+# 星期一
+
+整个20世纪（1901年1月1日至2000年12月31日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+5217
+```
+
+## 选项
+
+### A
+
+```cpp
+5218
+```
+
+### B
+
+```cpp
+5216
+```
+
+### C
+
+```cpp
+5210
+```

data/1.算法初阶/1.蓝桥杯-基础/30.生日蜡烛/config.json

+{
+  "node_id": "algorithm-5a3bc1e4f38648379d0f7be6d46a7648",
+  "keywords": [
+    "蓝桥杯",
+    "生日蜡烛"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/30.生日蜡烛/desc.md

+某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一吹熄了236根蜡烛。  
+请问，他从多少岁开始过生日party的？
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/30.生日蜡烛/solution.cpp

+#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

data/1.算法初阶/1.蓝桥杯-基础/30.生日蜡烛/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "ff9342bf7bcc48fba2718fdde83d1c0b"
+}
\ No newline at end of file

data/1.算法初阶/1.蓝桥杯-基础/30.生日蜡烛/solution.md

+# 生日蜡烛
+
+某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一吹熄了236根蜡烛。  
+请问，他从多少岁开始过生日party的？
+
+## aop
+
+### before
+
+```cpp
+
+```
+
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+26
+```
+
+## 选项
+
+### A
+
+```cpp
+24
+```
+
+### B
+
+```cpp
+25
+```
+
+### C
+
+```cpp
+27
+```

data/1.算法初阶/2.蓝桥杯-字符串/4.人物相关性分析/config.json

+{
+  "node_id": "algorithm-108089b131c346dabc981230a1cb4fb1",
+  "keywords": [
+    "蓝桥杯",
+    "人物相关性分析"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/2.蓝桥杯-字符串/4.人物相关性分析/desc.md

+小明正在分析一本小说中的人物相关性。
+
+他想知道在小说中 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

data/1.算法初阶/2.蓝桥杯-字符串/4.人物相关性分析/solution.cpp

+#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;
+}

data/1.算法初阶/2.蓝桥杯-字符串/4.人物相关性分析/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "f79d5efd471f46ec87d7069fb765f43d"
+}
\ No newline at end of file

data/1.算法初阶/2.蓝桥杯-字符串/4.人物相关性分析/solution.md

+# 人物相关性分析
+
+小明正在分析一本小说中的人物相关性。
+
+他想知道在小说中 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;
+}
+```

data/1.算法初阶/2.蓝桥杯-字符串/5.解码/config.json

+{
+  "node_id": "algorithm-216aba466fa84f069f09de86439271b1",
+  "keywords": [
+    "蓝桥杯",
+    "解码"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/2.蓝桥杯-字符串/5.解码/desc.md

+#### 问题描述
+
+小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
+
+例如，连续的 5 个 a，即 aaaaa，小明可以简写成 a5（也可能简写成 a4a、aa3a 等）。对于这个例子：HHHellllloo，小明可以简写成 H3el5o2。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
+现在给出简写后的字符串，请帮助小明还原成原来的串。
+
+#### 输入格式
+
+输入一行包含一个字符串。
+
+#### 输出格式
+
+输出一个字符串，表示还原后的串。
+
+#### 样例输入
+```
+H3el5o2
+```
+#### 样例输出
+```
+HHHellllloo
+```
+#### 评测用例规模与约定
+
+对于所有评测用例，字符串由大小写英文字母和数字组成，长度不超过100。
+
+请注意原来的串长度可能超过 100。
\ No newline at end of file

data/1.算法初阶/2.蓝桥杯-字符串/5.解码/solution.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')
+            {
+                s2[top++] = s1[i - 1];
+                s1[i] = s1[i] - 1;
+            }
+        }
+    }
+    s2[top] = '\0';
+
+    cout << s2;
+    return 0;
+}

data/1.算法初阶/2.蓝桥杯-字符串/5.解码/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "7f65d6a25e334652bfe898316850934e"
+}
\ No newline at end of file

data/1.算法初阶/2.蓝桥杯-字符串/5.解码/solution.md

+# 解码
+
+**问题描述**
+
+小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
+
+例如，连续的 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];
+```

data/1.算法初阶/3.蓝桥杯-递归/6.取数位/config.json

+{
+  "node_id": "algorithm-9e407b7a4ec844019c7a4db5b61ee004",
+  "keywords": [
+    "蓝桥杯",
+    "取数位"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/3.蓝桥杯-递归/6.取数位/desc.md

+求1个整数的第k位数字有很多种方法。
+
+以下的方法就是一种。
+

data/1.算法初阶/3.蓝桥杯-递归/6.取数位/solution.cpp

+#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

data/1.算法初阶/3.蓝桥杯-递归/6.取数位/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "4f854873186048839ba4c2a7da47f366"
+}
\ No newline at end of file

data/1.算法初阶/3.蓝桥杯-递归/6.取数位/solution.md

+# 取数位
+
+求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);
+```

data/1.算法初阶/3.蓝桥杯-递归/7.逆波兰表达式/config.json

+{
+  "node_id": "algorithm-b40b51c853e940adadaf01b5a205aa0c",
+  "keywords": [
+    "蓝桥杯",
+    "逆波兰表达式"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/3.蓝桥杯-递归/7.逆波兰表达式/desc.md

+正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。  
+例如：3 + 5 * (2 + 6) - 1  
+而且，常常需要用括号来改变运算次序。  
+相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：  
+```
+- + 3 * 5 + 2 6 1
+```
+不再需要括号，机器可以用递归的方法很方便地求解。
+为了简便，我们假设：
+1. 只有 $ + - * $ 三种运算符
+2. 每个运算数都是一个小于10的非负整数  
+
+下面的程序对一个逆波兰表示串进行求值。  
+其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。 

data/1.算法初阶/3.蓝桥杯-递归/7.逆波兰表达式/solution.cpp

+#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

data/1.算法初阶/3.蓝桥杯-递归/7.逆波兰表达式/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "c29652154669434cb71e4f036b690fef"
+}
\ No newline at end of file

data/1.算法初阶/3.蓝桥杯-递归/7.逆波兰表达式/solution.md

+# 逆波兰表达式
+
+正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。  
+例如：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);
+```

data/1.算法初阶/5.蓝桥杯-模拟/11.跑步锻炼/config.json

+{
+  "node_id": "algorithm-e41cd4349f6d4bbdb1801a6cdc95b57a",
+  "keywords": [
+    "蓝桥杯",
+    "跑步锻炼"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/5.蓝桥杯-模拟/11.跑步锻炼/desc.md

+小蓝每天都锻炼身体。  
+正常情况下，小蓝每天跑1千米。如果某天是周一或者月初（1日），为了激励自己，小蓝要跑2千米。如果同时是周一或月初，小蓝也是跑2千米。  
+小蓝跑步已经坚持了很长时间，从2000年1月1日周六（含）到2020年10月1日周四（含）。请问这段时间小蓝总共跑步多少千米？
\ No newline at end of file

data/1.算法初阶/5.蓝桥杯-模拟/11.跑步锻炼/solution.cpp

+#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;
+}

data/1.算法初阶/5.蓝桥杯-模拟/11.跑步锻炼/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "ebc12c88b5f049f684c3e7b63f44b6d7"
+}
\ No newline at end of file

data/1.算法初阶/5.蓝桥杯-模拟/11.跑步锻炼/solution.md

+# 跑步锻炼
+
+小蓝每天都锻炼身体。  
+正常情况下，小蓝每天跑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
+```

data/1.算法初阶/6.蓝桥杯-搜索/10.跳蚱蜢/config.json

+{
+  "node_id": "algorithm-daed047610e942a6bb5548f7acacdf3b",
+  "keywords": [
+    "蓝桥杯",
+    "跳蚱蜢"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/6.蓝桥杯-搜索/10.跳蚱蜢/desc.md

+有 9 只盘子，排成 1 个圆圈。
+
+其中 8 只盘子内装着 8 只蚱蜢，有一个是空盘，我们把这些蚱蜢顺时针编号为 1 ~ 8
+
+每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
+
+请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
+
+并且保持空盘的位置不变（也就是 1-8 换位，2-7 换位,…），至少要经过多少次跳跃？
+
+![](https://img-blog.csdnimg.cn/20200530104930106.png)
\ No newline at end of file

data/1.算法初阶/6.蓝桥杯-搜索/10.跳蚱蜢/solution.cpp

+#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;
+}

data/1.算法初阶/6.蓝桥杯-搜索/10.跳蚱蜢/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "f6527d9cc83345379fe1fedfa52a3b6a"
+}
\ No newline at end of file

data/1.算法初阶/6.蓝桥杯-搜索/10.跳蚱蜢/solution.md

+# 跳蚱蜢
+
+有 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;
+}
+```

data/1.算法初阶/6.蓝桥杯-搜索/11.网络分析/config.json

+{
+  "node_id": "algorithm-268291e6cb264bce97c6919f98c2c8f0",
+  "keywords": [
+    "蓝桥杯",
+    "网络分析"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/6.蓝桥杯-搜索/11.网络分析/desc.md

+#### 问题描述
+小明正在做一个网络实验。
+他设置了 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。
+```

data/1.算法初阶/6.蓝桥杯-搜索/11.网络分析/solution.cpp

+#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;
+}

data/1.算法初阶/6.蓝桥杯-搜索/11.网络分析/solution.json

+{
+  "type": "code_options",
+  "author": "CSDN.net",
+  "source": "solution.md",
+  "exercise_id": "1cd422764c9f4e5f9842a3195b91a919"
+}
\ No newline at end of file

data/1.算法初阶/6.蓝桥杯-搜索/11.网络分析/solution.md

+# 网络分析
+
+
+**问题描述**
+
+小明正在做一个网络实验。
+他设置了 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;
+}
+```

data/1.算法初阶/6.蓝桥杯-搜索/8.李白打酒/config.json

+{
+  "node_id": "algorithm-57652e0b6b054bb7871b0ec49edf5814",
+  "keywords": [
+    "蓝桥杯",
+    "李白打酒"
+  ],
+  "children": [],
+  "export": []
+}
\ No newline at end of file

data/1.算法初阶/6.蓝桥杯-搜索/8.李白打酒/desc.md

+话说大诗人李白，一生好饮。幸好他从不开车。  
+一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：  
+无事街上走，提壶去打酒。  
+逢店加一倍，遇花喝一斗。  
+这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。   
+请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

data/1.算法初阶/6.蓝桥杯-搜索/8.李白打酒/solution.cpp

+#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