Skip to content

S
skill_tree_algorithm

CSDN 技术社区 / skill_tree_algorithm

通知 9
Star 8
Fork 1
S
skill_tree_algorithm
提交 46e221cd 编写于 作者: 每日一练社区's avatar 每日一练社区
浏览文件
操作

update exercises

上级 d5ae4735
显示空白变更内容
内联 并排
Showing with 18481 addition and 55 deletion
.gitignore
浏览文件 @ 46e221cd
...@@ -7,3 +7,8 @@ __pycache__ ...@@ -7,3 +7,8 @@ __pycache__
help.py help.py
test.cpp test.cpp
a.out a.out
leetcode_template.md
auto_gen_leetcode_tem.py
leetcode_helper.py
lanqiao_helper.py
lanqiao_template.md
\ No newline at end of file
data/1.算法初阶/1.蓝桥杯/7段码/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 7段码
#### 题目描述
小蓝要用七段码数码管来表示一种特殊的文字。
![七段码](https://img-blog.csdnimg.cn/2020110916441977.png#pic_left)
上图给出了七段码数码管的一个图示，数码管中一共有 7 段可以发光的二极管，分别标记为 a, b, c, d, e, f, g。
小蓝要选择一部分二极管（至少要有一个）发光来表达字符。在设计字符的表达时，要求所有发光的二极管是连成一片的。
* 例如：b 发光，其他二极管不发光可以用来表达一种字符。
* 例如：c 发光，其他二极管不发光可以用来表达一种字符。
这种方案与上一行的方案可以用来表示不同的字符，尽管看上去比较相似。
* 例如：a, b, c, d, e 发光，f, g 不发光可以用来表达一种字符。
* 例如：b, f 发光，其他二极管不发光则不能用来表达一种字符，因为发光的二极管没有连成一片。
请问，小蓝可以用七段码数码管表达多少种不同的字符？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/9数算式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 9数算式
观察如下的算式：
```
9213 x 85674 = 789314562
```
左边的乘数和被乘数正好用到了1~9的所有数字，每个1次。
而乘积恰好也是用到了1~9的所有数字，并且每个1次。
请你借助计算机的强大计算能力，找出满足如上要求的9数算式一共有多少个？
注意：
1. 总数目包含题目给出的那个示例。
2. 乘数和被乘数交换后作为同一方案来看待。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/BST 插入节点问题/solution.md 0 → 100644
浏览文件 @ 46e221cd
# BST 插入节点问题
#### 问题描述
给定一棵包含 N 个节点的二叉树，节点编号是 1 ∼ N。其中 i 号节点具有权值 W i ，并且这些节点的权值恰好形成了一棵排序二叉树 (BST)。
现在给定一个节点编号 K，小明想知道，在这 N 个权值以外，有多少个整数 X (即 X 不等于任何 W i ) 满足：给编号为 K 的节点增加一个权值为 X 的子节点，仍可以得到一棵 BST。
例如在下图中，括号外的数字表示编号、括号内的数字表示权值。即编号1 ∼ 4 的节点权值依次是 0、10、20、30。
![](https://img-blog.csdnimg.cn/20201010210318917.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L01pbGtMZW9uZw==,size_16,color_FFFFFF,t_70#pic_center)
如果 K = 1，那么答案为 0。因为 1 号节点已经有左右子节点，不能再增加子节点了。
如果 K = 2，那么答案为无穷多。因为任何一个负数都可以作为 2 的左子节点。
如果 K = 3，那么答案为 9。因为 X = 11,12,··· ,19 都可以作为 3 的左子节点。
#### 输入格式
第一行包含 2 个整数 N 和 K。
以下 N 行每行包含 2 个整数，其中第 i 行是编号为 i 的节点的父节点编号P i 和权值 W i 。注意 P i = 0 表示 i 是根节点。
输入保证是一棵 BST。
#### 输出格式
一个整数代表答案。如果答案是无穷多，输出 −1。
#### 样例输入
```
4 3
0 10
1 0
1 20
3 30
```
#### 样例输出
```
9
```
#### 评测用例规模与约定
对于 60% 的评测用例，1 ≤ K ≤ N ≤ 100，0 ≤ W i ≤ 200，且 W i 各不相同。
对于所有评测用例，1 ≤ K ≤ N ≤ 10000，0 ≤ W i ≤ 100000000，且 W i 各不相同。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/REPEAT 程序/solution.md 0 → 100644
浏览文件 @ 46e221cd
# REPEAT 程序
附件 prog.txt 中是一个用某种语言写的程序。附件在本文的末尾。
其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达，从次行开始连续的缩进比该行多的（前面的空白更长的）为循环包含的内容。
![](https://img-blog.csdnimg.cn/20210320200704647.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MDEzMjQ3,size_16,color_FFFFFF,t_70)
该片段中从 A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的循环两次中。
REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
请问该程序执行完毕之后，A 的值是多少？
题目给出的 prog.txt 文件：
```
A = 0
REPEAT 2:
A = A + 4
REPEAT 5:
REPEAT 6:
A = A + 5
A = A + 7
REPEAT 6:
A = A + 7
REPEAT 4:
A = A + 2
A = A + 7
A = A + 2
REPEAT 7:
REPEAT 4:
A = A + 8
A = A + 7
A = A + 4
A = A + 5
A = A + 8
REPEAT 8:
A = A + 5
REPEAT 1:
A = A + 2
REPEAT 7:
A = A + 5
A = A + 5
REPEAT 2:
REPEAT 3:
A = A + 1
A = A + 1
REPEAT 5:
A = A + 1
REPEAT 9:
REPEAT 6:
A = A + 5
A = A + 1
REPEAT 6:
A = A + 2
A = A + 8
A = A + 3
REPEAT 2:
A = A + 5
REPEAT 3:
A = A + 9
REPEAT 1:
A = A + 4
REPEAT 2:
A = A + 9
REPEAT 1:
A = A + 6
A = A + 6
A = A + 4
REPEAT 3:
A = A + 7
A = A + 1
REPEAT 2:
A = A + 3
REPEAT 5:
A = A + 2
A = A + 5
A = A + 2
A = A + 4
A = A + 3
REPEAT 4:
A = A + 4
A = A + 3
A = A + 7
REPEAT 5:
REPEAT 4:
A = A + 5
A = A + 7
REPEAT 5:
A = A + 3
REPEAT 3:
A = A + 3
A = A + 1
A = A + 8
A = A + 2
REPEAT 9:
A = A + 5
REPEAT 1:
A = A + 5
A = A + 2
A = A + 8
A = A + 6
REPEAT 3:
REPEAT 4:
A = A + 9
REPEAT 5:
A = A + 2
A = A + 1
REPEAT 9:
A = A + 9
A = A + 2
REPEAT 1:
A = A + 6
A = A + 8
REPEAT 2:
A = A + 9
A = A + 4
A = A + 7
REPEAT 2:
REPEAT 7:
A = A + 3
A = A + 5
REPEAT 3:
A = A + 5
A = A + 3
A = A + 6
A = A + 4
REPEAT 9:
A = A + 2
A = A + 8
A = A + 2
A = A + 3
REPEAT 2:
REPEAT 8:
A = A + 5
A = A + 1
A = A + 6
A = A + 1
A = A + 2
REPEAT 6:
REPEAT 1:
A = A + 3
REPEAT 1:
A = A + 2
REPEAT 4:
A = A + 7
A = A + 1
A = A + 8
REPEAT 6:
A = A + 5
REPEAT 6:
A = A + 3
REPEAT 2:
A = A + 2
A = A + 9
A = A + 7
REPEAT 9:
A = A + 8
REPEAT 9:
A = A + 8
A = A + 9
A = A + 3
A = A + 2
REPEAT 6:
A = A + 3
REPEAT 9:
A = A + 1
A = A + 9
A = A + 5
REPEAT 2:
A = A + 4
A = A + 9
A = A + 8
REPEAT 5:
A = A + 6
A = A + 9
A = A + 1
REPEAT 1:
A = A + 4
A = A + 2
REPEAT 9:
REPEAT 3:
A = A + 4
REPEAT 7:
A = A + 8
A = A + 3
REPEAT 5:
A = A + 9
REPEAT 8:
A = A + 9
A = A + 8
REPEAT 4:
A = A + 7
A = A + 7
A = A + 3
A = A + 5
REPEAT 6:
A = A + 7
REPEAT 7:
A = A + 2
A = A + 2
A = A + 1
REPEAT 8:
REPEAT 1:
REPEAT 4:
A = A + 6
A = A + 6
A = A + 2
REPEAT 5:
A = A + 4
A = A + 8
A = A + 4
REPEAT 1:
A = A + 5
REPEAT 7:
A = A + 8
REPEAT 6:
A = A + 4
A = A + 4
A = A + 8
REPEAT 4:
A = A + 2
REPEAT 2:
A = A + 4
REPEAT 2:
A = A + 3
REPEAT 1:
A = A + 2
A = A + 8
REPEAT 2:
A = A + 7
REPEAT 8:
A = A + 6
A = A + 1
A = A + 7
REPEAT 8:
A = A + 2
REPEAT 8:
REPEAT 6:
A = A + 1
A = A + 6
REPEAT 2:
A = A + 4
A = A + 1
A = A + 7
A = A + 4
REPEAT 4:
REPEAT 9:
A = A + 2
REPEAT 1:
A = A + 2
A = A + 5
REPEAT 8:
REPEAT 6:
A = A + 3
REPEAT 4:
A = A + 1
A = A + 6
A = A + 1
REPEAT 7:
A = A + 7
REPEAT 7:
A = A + 3
A = A + 9
A = A + 1
A = A + 9
REPEAT 3:
A = A + 5
A = A + 5
A = A + 6
A = A + 2
REPEAT 1:
A = A + 4
REPEAT 2:
A = A + 7
REPEAT 1:
A = A + 7
REPEAT 4:
A = A + 7
A = A + 2
REPEAT 5:
A = A + 9
A = A + 1
A = A + 9
A = A + 5
A = A + 9
REPEAT 5:
A = A + 5
REPEAT 1:
A = A + 6
REPEAT 2:
A = A + 3
A = A + 2
A = A + 6
A = A + 8
A = A + 8
A = A + 7
A = A + 5
A = A + 5
REPEAT 2:
A = A + 1
A = A + 7
A = A + 3
REPEAT 2:
A = A + 7
A = A + 1
A = A + 4
REPEAT 1:
REPEAT 7:
REPEAT 2:
A = A + 3
A = A + 5
A = A + 2
A = A + 6
A = A + 1
A = A + 2
A = A + 4
A = A + 9
REPEAT 1:
A = A + 8
REPEAT 8:
REPEAT 4:
REPEAT 8:
A = A + 4
REPEAT 3:
A = A + 1
A = A + 8
REPEAT 7:
A = A + 8
REPEAT 7:
A = A + 7
A = A + 7
REPEAT 7:
A = A + 6
REPEAT 5:
A = A + 9
A = A + 3
REPEAT 4:
A = A + 5
A = A + 5
A = A + 4
REPEAT 9:
REPEAT 3:
A = A + 4
A = A + 3
A = A + 6
REPEAT 1:
A = A + 3
A = A + 3
A = A + 6
REPEAT 6:
A = A + 7
A = A + 7
A = A + 5
A = A + 5
A = A + 1
A = A + 2
A = A + 6
A = A + 6
REPEAT 9:
A = A + 6
REPEAT 1:
REPEAT 2:
A = A + 4
A = A + 7
REPEAT 3:
A = A + 6
REPEAT 5:
A = A + 3
A = A + 6
REPEAT 9:
A = A + 3
A = A + 6
REPEAT 5:
A = A + 8
A = A + 8
REPEAT 3:
A = A + 7
A = A + 9
A = A + 8
A = A + 3
A = A + 3
A = A + 9
REPEAT 6:
A = A + 9
A = A + 1
REPEAT 4:
REPEAT 1:
A = A + 7
REPEAT 9:
A = A + 2
A = A + 9
A = A + 1
A = A + 2
A = A + 8
A = A + 7
A = A + 9
A = A + 6
REPEAT 4:
REPEAT 2:
A = A + 3
REPEAT 3:
A = A + 4
A = A + 4
REPEAT 6:
A = A + 6
A = A + 1
A = A + 5
A = A + 8
REPEAT 2:
A = A + 6
REPEAT 1:
REPEAT 2:
A = A + 2
REPEAT 3:
A = A + 1
REPEAT 1:
A = A + 8
A = A + 7
A = A + 4
A = A + 2
A = A + 8
A = A + 4
REPEAT 5:
REPEAT 6:
A = A + 8
REPEAT 9:
A = A + 5
A = A + 5
REPEAT 5:
A = A + 5
REPEAT 3:
REPEAT 5:
A = A + 4
REPEAT 4:
A = A + 6
A = A + 3
REPEAT 7:
A = A + 3
A = A + 3
A = A + 1
A = A + 7
A = A + 7
A = A + 6
A = A + 5
A = A + 5
A = A + 6
REPEAT 1:
A = A + 9
A = A + 3
REPEAT 1:
REPEAT 1:
A = A + 1
REPEAT 8:
A = A + 5
REPEAT 8:
A = A + 6
REPEAT 4:
A = A + 9
A = A + 4
REPEAT 2:
A = A + 3
A = A + 7
REPEAT 5:
A = A + 7
A = A + 5
A = A + 8
A = A + 7
A = A + 8
A = A + 5
REPEAT 2:
A = A + 5
A = A + 7
A = A + 8
A = A + 5
A = A + 9
REPEAT 2:
REPEAT 6:
A = A + 9
A = A + 1
A = A + 8
A = A + 7
A = A + 1
A = A + 5
REPEAT 3:
A = A + 3
A = A + 9
A = A + 7
REPEAT 3:
A = A + 9
A = A + 1
REPEAT 6:
A = A + 1
REPEAT 9:
REPEAT 7:
A = A + 3
REPEAT 5:
A = A + 5
A = A + 8
A = A + 8
A = A + 1
A = A + 2
REPEAT 4:
A = A + 6
REPEAT 3:
A = A + 3
A = A + 7
REPEAT 8:
REPEAT 1:
A = A + 7
A = A + 8
A = A + 3
A = A + 1
A = A + 2
A = A + 4
A = A + 7
REPEAT 1:
REPEAT 1:
REPEAT 1:
A = A + 4
A = A + 6
REPEAT 1:
A = A + 3
A = A + 9
A = A + 6
REPEAT 9:
A = A + 1
A = A + 6
REPEAT 5:
A = A + 3
A = A + 9
A = A + 5
A = A + 5
A = A + 7
A = A + 2
REPEAT 2:
A = A + 7
A = A + 7
REPEAT 7:
REPEAT 4:
A = A + 6
A = A + 8
REPEAT 6:
A = A + 6
REPEAT 2:
A = A + 1
A = A + 7
A = A + 6
A = A + 7
REPEAT 4:
REPEAT 7:
A = A + 1
REPEAT 2:
A = A + 2
A = A + 5
A = A + 8
A = A + 2
A = A + 1
A = A + 4
REPEAT 8:
A = A + 5
A = A + 6
REPEAT 7:
REPEAT 6:
REPEAT 9:
A = A + 7
A = A + 8
REPEAT 4:
A = A + 6
A = A + 4
A = A + 3
A = A + 6
REPEAT 9:
A = A + 3
REPEAT 9:
A = A + 2
A = A + 7
A = A + 5
A = A + 2
REPEAT 7:
REPEAT 8:
REPEAT 6:
A = A + 4
A = A + 9
A = A + 5
A = A + 3
A = A + 9
REPEAT 4:
REPEAT 1:
A = A + 6
A = A + 8
REPEAT 1:
A = A + 6
A = A + 4
A = A + 6
REPEAT 3:
A = A + 7
REPEAT 3:
A = A + 4
A = A + 4
A = A + 2
A = A + 3
A = A + 7
REPEAT 5:
A = A + 6
A = A + 5
REPEAT 1:
REPEAT 8:
A = A + 5
REPEAT 3:
A = A + 6
REPEAT 9:
A = A + 4
A = A + 3
REPEAT 6:
REPEAT 2:
A = A + 1
A = A + 5
A = A + 2
A = A + 2
A = A + 7
REPEAT 4:
A = A + 7
A = A + 9
A = A + 2
REPEAT 8:
A = A + 9
REPEAT 9:
REPEAT 2:
A = A + 3
A = A + 2
A = A + 1
A = A + 5
REPEAT 9:
A = A + 1
A = A + 3
A = A + 9
REPEAT 7:
A = A + 2
REPEAT 5:
A = A + 9
A = A + 3
REPEAT 2:
A = A + 4
REPEAT 8:
A = A + 9
REPEAT 5:
A = A + 5
A = A + 4
A = A + 2
A = A + 4
REPEAT 6:
A = A + 2
REPEAT 5:
A = A + 7
A = A + 7
A = A + 8
A = A + 3
REPEAT 8:
A = A + 2
A = A + 5
REPEAT 1:
A = A + 8
A = A + 5
A = A + 1
A = A + 1
A = A + 5
REPEAT 2:
A = A + 6
REPEAT 6:
A = A + 9
A = A + 2
A = A + 5
REPEAT 4:
A = A + 7
A = A + 1
REPEAT 6:
A = A + 8
A = A + 4
REPEAT 3:
REPEAT 2:
A = A + 1
A = A + 5
REPEAT 2:
A = A + 7
REPEAT 9:
A = A + 6
A = A + 8
A = A + 9
A = A + 5
REPEAT 9:
REPEAT 3:
A = A + 7
A = A + 7
A = A + 9
A = A + 7
REPEAT 5:
A = A + 7
A = A + 2
A = A + 1
A = A + 8
A = A + 3
A = A + 5
A = A + 1
REPEAT 8:
A = A + 4
A = A + 2
A = A + 2
A = A + 8
REPEAT 4:
REPEAT 4:
A = A + 8
REPEAT 7:
A = A + 5
A = A + 2
REPEAT 2:
A = A + 6
REPEAT 4:
A = A + 8
A = A + 6
A = A + 1
A = A + 3
A = A + 2
A = A + 7
A = A + 4
REPEAT 8:
A = A + 2
A = A + 4
REPEAT 5:
REPEAT 3:
REPEAT 6:
A = A + 8
A = A + 1
A = A + 6
A = A + 5
A = A + 9
REPEAT 8:
A = A + 7
REPEAT 6:
A = A + 4
A = A + 5
REPEAT 3:
A = A + 1
REPEAT 1:
REPEAT 5:
A = A + 6
A = A + 2
REPEAT 9:
REPEAT 5:
A = A + 9
A = A + 3
REPEAT 9:
A = A + 9
A = A + 8
REPEAT 8:
REPEAT 5:
A = A + 9
A = A + 4
REPEAT 9:
A = A + 3
A = A + 4
A = A + 5
REPEAT 9:
REPEAT 7:
A = A + 5
REPEAT 3:
A = A + 7
REPEAT 9:
REPEAT 6:
A = A + 4
A = A + 6
REPEAT 5:
REPEAT 6:
A = A + 5
A = A + 3
A = A + 3
A = A + 3
A = A + 5
REPEAT 7:
A = A + 5
REPEAT 2:
A = A + 5
A = A + 6
REPEAT 2:
A = A + 2
A = A + 5
A = A + 3
A = A + 5
A = A + 5
REPEAT 4:
A = A + 2
A = A + 1
REPEAT 9:
A = A + 9
A = A + 5
A = A + 6
A = A + 2
A = A + 2
A = A + 5
REPEAT 9:
A = A + 5
A = A + 4
REPEAT 4:
REPEAT 4:
A = A + 1
A = A + 2
REPEAT 6:
A = A + 9
A = A + 3
REPEAT 2:
A = A + 5
A = A + 1
A = A + 1
A = A + 3
A = A + 8
REPEAT 7:
A = A + 4
REPEAT 6:
A = A + 9
REPEAT 5:
A = A + 9
A = A + 8
A = A + 3
A = A + 9
A = A + 4
A = A + 6
REPEAT 7:
A = A + 9
REPEAT 9:
A = A + 4
A = A + 9
A = A + 1
A = A + 3
REPEAT 5:
REPEAT 1:
A = A + 4
A = A + 4
REPEAT 8:
A = A + 9
A = A + 6
A = A + 2
REPEAT 3:
A = A + 4
A = A + 4
REPEAT 3:
A = A + 5
A = A + 2
A = A + 8
A = A + 3
A = A + 6
A = A + 4
A = A + 9
A = A + 1
A = A + 9
A = A + 5
A = A + 3
REPEAT 3:
A = A + 2
A = A + 5
A = A + 8
A = A + 2
A = A + 5
REPEAT 8:
REPEAT 2:
A = A + 6
A = A + 7
A = A + 6
A = A + 9
A = A + 2
REPEAT 2:
A = A + 3
REPEAT 8:
A = A + 7
A = A + 2
A = A + 1
A = A + 4
A = A + 1
A = A + 5
A = A + 2
A = A + 1
REPEAT 1:
A = A + 1
REPEAT 6:
A = A + 4
A = A + 3
A = A + 3
REPEAT 5:
A = A + 3
REPEAT 6:
REPEAT 1:
A = A + 5
A = A + 7
A = A + 7
A = A + 7
REPEAT 5:
A = A + 9
A = A + 7
REPEAT 5:
A = A + 9
A = A + 1
A = A + 9
A = A + 8
REPEAT 1:
A = A + 2
REPEAT 5:
A = A + 8
REPEAT 3:
A = A + 2
A = A + 9
A = A + 6
A = A + 3
REPEAT 5:
REPEAT 6:
A = A + 5
A = A + 5
REPEAT 4:
A = A + 5
A = A + 4
REPEAT 8:
A = A + 9
A = A + 1
REPEAT 8:
A = A + 8
A = A + 1
A = A + 4
REPEAT 6:
A = A + 6
REPEAT 2:
A = A + 3
A = A + 9
A = A + 6
A = A + 9
REPEAT 1:
A = A + 4
REPEAT 3:
A = A + 3
A = A + 4
A = A + 2
A = A + 8
REPEAT 2:
A = A + 4
A = A + 1
REPEAT 9:
A = A + 2
A = A + 9
A = A + 7
REPEAT 7:
REPEAT 7:
REPEAT 5:
A = A + 7
REPEAT 5:
A = A + 1
A = A + 1
REPEAT 5:
A = A + 6
REPEAT 1:
A = A + 4
REPEAT 9:
A = A + 4
A = A + 1
REPEAT 6:
A = A + 8
A = A + 5
REPEAT 1:
A = A + 4
REPEAT 5:
A = A + 8
A = A + 7
A = A + 2
REPEAT 3:
A = A + 3
REPEAT 8:
REPEAT 8:
A = A + 4
A = A + 7
REPEAT 5:
A = A + 1
REPEAT 8:
A = A + 7
A = A + 8
A = A + 4
A = A + 7
A = A + 6
A = A + 9
A = A + 5
REPEAT 3:
A = A + 5
REPEAT 9:
A = A + 1
A = A + 7
REPEAT 1:
A = A + 8
A = A + 4
REPEAT 8:
REPEAT 7:
A = A + 2
REPEAT 4:
A = A + 6
A = A + 6
REPEAT 1:
A = A + 7
A = A + 1
REPEAT 9:
REPEAT 5:
A = A + 6
A = A + 5
REPEAT 7:
A = A + 3
A = A + 6
A = A + 8
REPEAT 2:
A = A + 7
A = A + 1
A = A + 9
REPEAT 3:
REPEAT 3:
A = A + 5
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/RSA 解密/solution.md 0 → 100644
浏览文件 @ 46e221cd
# RSA 解密
RSA是一种经典的加密算法。它的基本加密过程如下。
首先生成两个质数p,q, 令$n = p \cdot q$,设d与$(p-1) \cdot (q-1)$互质，则可以找到e,使得$d \cdot e$除以$(p-1) \cdot (q-1)$的余数为1
n,d,e组成了私钥，n,d构成了公钥。
当使用公钥加密一个整数X时(X<=n-1)，计算$C = X^d$ mod n，则C是加密后的密文。
当收到密文C时，可以使用私钥解开，计算公式为：$X = C^e$ mod n。
例如：当p = 5, q = 11, n = 55, e = 27。
若加密数字24,得$24^3$ % 55 = 19。
解密数字19，得$19^{27}$ % 55 = 24。
现在你知道公钥中n = 1001733993063167141,d = 212353,同时，你截获了别人发送的密文C = 20190324,请问，原文是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/k倍区间/solution.md 0 → 100644
浏览文件 @ 46e221cd
# k倍区间
#### 问题描述
给定一个长度为N的数列，$A_1, A_2, … A_N，$如果其中一段连续的子序列$A_i, A_{i+1}, … A_j(i <= j)$之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
#### 输入格式
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数$A_i$。(1 <= $A_i$ <= 100000)
#### 输出格式
输出一个整数，代表K倍区间的数目。
#### 样例输入
```
5 2
1
2
3
4
5
```
#### 样例输出
```
6
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/三体攻击/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 三体攻击
#### 题目描述
三体人将对地球发起攻击。为了抵御攻击，地球人派出了 A × B × C 艘战舰，在太空中排成一个 A 层 B 行 C 列的立方体。其中，第 i 层第 j 行第 k 列的战舰（记为战舰 (i, j, k)）的生命值为 d(i, j, k)。
三体人将会对地球发起 m 轮“立方体攻击”，每次攻击会对一个小立方体中的所有战舰都造成相同的伤害。具体地，第 t 轮攻击用 7 个参数 $la_t, ra_t, lb_t, rb_t, lc_t, rc_t, h_t $描述；
所有满足$ i ∈ [la_t, ra_t],j ∈ [lb_t, rb_t],k ∈ [lc_t, rc_t] $的战舰 (i, j, k) 会受到 $h_t$ 的伤害。如果一个战舰累计受到的总伤害超过其防御力，那么这个战舰会爆炸。
地球指挥官希望你能告诉他，第一艘爆炸的战舰是在哪一轮攻击后爆炸的。
#### 输入格式
从标准输入读入数据。
第一行包括 4 个正整数 A, B, C, m；
第二行包含 A × B × C 个整数，其中第 ((i − 1)×B + (j − 1)) × C + (k − 1)+1 个数为 d(i, j, k)；
第 3 到第 m + 2 行中，第 (t − 2) 行包含 7 个正整数 $la_t, ra_t, lb_t, rb_t, lc_t, rc_t, h_t$。
#### 输出格式
输出到标准输出。
输出第一个爆炸的战舰是在哪一轮攻击后爆炸的。保证一定存在这样的战舰。
#### 样例输入
```
2 2 2 3
1 1 1 1 1 1 1 1
1 2 1 2 1 1 1
1 1 1 2 1 2 1
1 1 1 1 1 1 2
```
#### 样例输出
```
2
```
#### 样例解释
在第 2 轮攻击后，战舰 (1,1,1) 总共受到了 2 点伤害，超出其防御力导致爆炸。
#### 数据约定
```
对于 10% 的数据，B = C = 1；
对于 20% 的数据，C = 1；
对于 40% 的数据，A × B × C, m ≤ 10, 000；
对于 70% 的数据，A, B, C ≤ 200；
对于所有数据，A × B × C ≤ 10^6, m ≤ 10^6, 0 ≤ d(i, j, k), ht ≤ 10^9。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/三羊献瑞/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 三羊献瑞
观察下面的加法算式：
![](https://img-blog.csdnimg.cn/20200323231451860.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxMDMyMA==,size_16,color_FFFFFF,t_70#pic_center)
其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。
请你填写“三羊献瑞”所代表的4位数字（答案唯一）
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/三角形面积/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 三角形面积
已知三角形三个顶点在直角坐标系下的坐标分别为：
```
（2.3,2.5）
（6.4,3.1）
（5.1,7.2）
```
求该三角形的面积。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/三部排序/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 三部排序
一般的排序有许多经典算法，如快速排序、希尔排序等。但实际应用时，经常会或多或少有一些特殊的要求。我们没必要套用那些经典算法，可以根据实际情况建立更好的解法。
比如，对一个整型数组中的数字进行分类排序：
使得负数都靠左端，正数都靠右端，0在中部。注意问题的特点是：负数区域和正数区域内并不要求有序。可以利用这个特点通过1次线性扫描就结束战斗!!
以下的程序实现了该目标。
其中x指向待排序的整型数组，len是数组的长度。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/不同子串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 不同子串
#### 题目描述
一个字符串的非空子串是指字符串中长度至少为1 的连续的一段字符组成的串。
例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共7 个。
注意在计算时，只算本质不同的串的个数。
请问，字符串```0100110001010001```有多少个不同的非空子串？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/世纪末的星期/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 世纪末的星期
曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。
还有人称今后的某个世纪末的12月31日，如果是星期一则会....
有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!
于是，“谣言制造商”又修改为星期日......
1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？
请回答该年份（只写这个4位整数，不要写12月31等多余信息）
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/乘积尾零/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 乘积尾零
如下的10行数据，每行有10个整数，请你求出它们的乘积的末尾有多少个零？
```
5650 4542 3554 473 946 4114 3871 9073 90 4329
2758 7949 6113 5659 5245 7432 3051 4434 6704 3594
9937 1173 6866 3397 4759 7557 3070 2287 1453 9899
1486 5722 3135 1170 4014 5510 5120 729 2880 9019
2049 698 4582 4346 4427 646 9742 7340 1230 7683
5693 7015 6887 7381 4172 4341 2909 2027 7355 5649
6701 6645 1671 5978 2704 9926 295 3125 3878 6785
2066 4247 4800 1578 6652 4616 1113 6205 3264 2915
3966 5291 2904 1285 2193 1428 2265 8730 9436 7074
689 5510 8243 6114 337 4096 8199 7313 3685 211
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/乘积最大/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 乘积最大
给定 N 个整数 A1,A2,…AN。
请你从中选出 K 个数，使其乘积最大。
请你求出最大的乘积，由于乘积可能超出整型范围，你只需输出乘积除以 1000000009 的余数。
注意，如果 X<0， 我们定义 X 除以 1000000009 的余数是负(−X)除以 1000000009 的余数，即：0−((0−x)%1000000009)
#### 输入格式
第一行包含两个整数 N 和 K。
以下 N 行每行一个整数 Ai。
#### 输出格式
输出一个整数，表示答案。
#### 数据范围
```
1≤K≤N≤105,
−105≤Ai≤105
```
#### 输入样例1：
```
5 3
-100000
-10000
2
100000
10000
```
#### 输出样例1：
```
999100009
```
#### 输入样例2：
```
5 3
-100000
-100000
-2
-100000
-100000
#### 输出样例2：
-999999829
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/九数分三组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 九数分三组
1~9的数字可以组成3个3位数，设为：A,B,C, 现在要求满足如下关系：
```
B = 2 * A
C = 3 * A
```
请你写出A的所有可能答案，数字间用空格分开，数字按升序排列。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/九数组分数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 九数组分数
1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/书号验证/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 书号验证
2004年起，国际ISBN中心出版了《13位国际标准书号指南》。
原有10位书号前加978作为商品分类标识；校验规则也改变。
校验位的加权算法与10位ISBN的算法不同，具体算法是：
1. 用1分别乘ISBN的前12位中的奇数位（从左边开始数起），用3乘以偶数位，乘积之和以10为模，
2. 10与模值的差值再对10取模（即取个位的数字）即可得到校验位的值，其值范围应该为0~9。
下面的程序实现了该算法，请仔细阅读源码，填写缺失的部分。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/买不到的数目/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 买不到的数目
#### 问题描述
小明开了一家糖果店。他别出心裁：把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。
小朋友来买糖的时候，他就用这两种包装来组合。当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。
你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。大于17的任何数字都可以用4和7组合出来。
本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。
#### 输入格式
两个正整数，表示每种包装中糖的颗数(都不多于1000)
#### 输出格式
一个正整数，表示最大不能买到的糖数
#### 样例输入1
```
4 7
```
#### 样例输出1
```
17
```
#### 样例输入2
```
3 5
```
#### 样例输出2
```
7
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/交换瓶子/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 交换瓶子
有N个瓶子，编号 1 ~ N，放在架子上。
比如有5个瓶子：
2 1 3 5 4
要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5
对于这么简单的情况，显然，至少需要交换2次就可以复位。
如果瓶子更多呢？你可以通过编程来解决。
输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。
输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。
例如，输入：
```
5
3 1 2 5 4
```
程序应该输出：
```
3
```
再例如，输入：
```
5
5 4 3 2 1
```
程序应该输出：
```
2
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/人物相关性分析/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 人物相关性分析
小明正在分析一本小说中的人物相关性。
他想知道在小说中 Alice 和 Bob 有多少次同时出现。
更准确的说，小明定义 Alice 和 Bob “同时出现”的意思是：在小说文本中 Alice 和 Bob 之间不超过 K 个字符。
例如以下文本：
```
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
```
假设 K=20，则 Alice 和 Bob 同时出现了 2 次，分别是 Alice and Bob 和 Bob. Alice。
前者 Alice 和 Bob 之间有 5 个字符，后者有 2 个字符。
注意:
1. Alice 和 Bob 是大小写敏感的，alice 或 bob 等并不计算在内。
2. Alice 和 Bob 应为单独的单词，前后可以有标点符号和空格，但是不能有字母。例如 Bobbi 並不算出现了 Bob。
#### 输入格式
第一行包含一个整数 K。
第二行包含一行字符串，只包含大小写字母、标点符号和空格。长度不超过 1000000。
#### 输出格式
输出一个整数，表示 Alice 和 Bob 同时出现的次数。
#### 数据范围
```
1≤K≤1000000
```
#### 输入样例：
```
20
This is a story about Alice and Bob. Alice wants to send a private message to Bob.
```
输出样例：
```
2
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/付账问题/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 付账问题
#### 题目描述
几个人一起出去吃饭是常有的事。但在结帐的时候，常常会出现一些争执。
现在有 n 个人出去吃饭，他们总共消费了 S 元。其中第 i 个人带了 ai 元。幸运的是，所有人带的钱的总数是足够付账的，但现在问题来了：每个人分别要出多少钱呢？
为了公平起见，我们希望在总付钱量恰好为 S 的前提下，最后每个人付的钱的标准差最小。这里我们约定，每个人支付的钱数可以是任意非负实数，即可以不是1分钱的整数倍。你需要输出最小的标准差是多少。
标准差的介绍：标准差是多个数与它们平均数差值的平方平均数，一般用于刻画这些数之间的“偏差有多大”。形式化地说，设第 i 个人付的钱为 bi 元，那么标准差为 :
![参见p1.png](https://img-blog.csdnimg.cn/20201015164915888.png#pic_center)
#### 输入格式
从标准输入读入数据。
第一行包含两个整数 n、S；
第二行包含 n 个非负整数 a1, …, an。
#### 输出格式
输出到标准输出。
输出最小的标准差，四舍五入保留 4 位小数。
保证正确答案在加上或减去 10^−9 后不会导致四舍五入的结果发生变化。
#### 样例1输入
```
5 2333
666 666 666 666 666
```
#### 样例输出
```
0.0000
```
#### 样例解释
每个人都出 2333/5 元，标准差为 0。
#### 样例输入
```
10 30
2 1 4 7 4 8 3 6 4 7
```
#### 样例输出
```
0.7928
```
#### 数据说明
对于 10% 的数据，所有 ai 相等；
对于 30% 的数据，所有非 0 的 ai 相等；
对于 60% 的数据，n ≤ 1000；
对于 80% 的数据，n ≤ 10^5；
对于所有数据，n ≤ 5 × 10^5, 0 ≤ ai ≤ 10^9。
#### 资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/修改数组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 修改数组
#### 问题描述
给定一个长度为 N 的数组$ A = [A_1; A_2; · · · A_N]$，数组中有可能有重复出现的整数。
现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改$A_2, A_3, · · · , A_N$。
当修改 $A_i$时，小明会检查 $A_i$ 是否在$ A_1 ∼ A_{i−1} $中出现过。如果出现过，则小明会给$ A_i $加上 1 ；如果新的$ A_i $仍在之前出现过，小明会持续给$ A_i $加 1 ，直到$ A_i $没有在$ A_1 ∼ A_{i−1}$ 中出现过。
当$ A_N $也经过上述修改之后，显然 A 数组中就没有重复的整数了。
现在给定初始的 A 数组，请你计算出最终的 A 数组。
#### 输入格式
第一行包含一个整数 N。
第二行包含 N 个整数$ A_1; A_2; · · · ; A_N $。
#### 输出格式
输出 N 个整数，依次是最终的$ A_1; A_2; · · · ; A_N $。
#### 样例输入
```
5
2 1 1 3 4
```
#### 样例输出
```
2 1 3 4 5
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/倍数问题/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 倍数问题
#### 题目描述
众所周知，小葱同学擅长计算，尤其擅长计算一个数是否是另外一个数的倍数。但小葱只擅长两个数的情况，当有很多个数之后就会比较苦恼。现在小葱给了你 n 个数，希望你从这 n 个数中找到三个数，使得这三个数的和是 K 的倍数，且这个和最大。数据保证一定有解。
#### 输入格式
从标准输入读入数据。
第一行包括 2 个正整数 n, K。
第二行 n 个正整数，代表给定的 n 个数。
#### 输出格式
输出到标准输出。
输出一行一个整数代表所求的和。
#### 样例输入
```
4 3
1 2 3 4
```
#### 样例输出
```
9
```
#### 样例解释
```
选择2、3、4。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/全球变暖/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 全球变暖
你有一张某海域 N×N 像素的照片，”.”表示海洋、”#”表示陆地，如下所示：
```
.......
.##....
.##....
....##.
..####.
...###.
.......
```
其中”上下左右”四个方向上连在一起的一片陆地组成一座岛屿，例如上图就有 2 座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。
具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
```
.......
.......
.......
.......
....#..
.......
.......
```
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
#### 输入格式
第一行包含一个整数N。
以下 N 行 N 列，包含一个由字符”#”和”.”构成的 N×N 字符矩阵，代表一张海域照片，”#”表示陆地，”.”表示海洋。
照片保证第 1 行、第 1 列、第 N 行、第 N 列的像素都是海洋。
#### 输出格式
一个整数表示答案。
#### 数据范围
```
1≤N≤1000
```
#### 输入样例1：
```
7
.......
.##....
.##....
....##.
..####.
...###.
.......
```
#### 输出样例1：
```
1
```
#### 输入样例2：
```
9
.........
.##.##...
.#####...
.##.##...
.........
.##.#....
.#.###...
.#..#....
.........
```
#### 输出样例2：
```
1
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/八次求和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 八次求和
#### 问题描述
给定正整数 n, 求 1^8 + 2^8 +···+ n^8 mod 123456789 。其中 mod 表示取余。
#### 输入格式
输入的第一行包含一个整数 n。
#### 输出格式
输出一行，包含一个整数，表示答案。
#### 样例输入
```
2
```
#### 样例输出
```
257
```
#### 样例输入
```
987654
```
#### 样例输出
```
43636805
```
#### 评测用例规模与约定
对于 20% 的评测用例，1≤n≤20。
对于 60% 的评测用例，1≤n≤1000。
对于所有评测用例，1≤n≤1000000。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/六角填数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 六角填数
如图所示六角形中，填入1~12的数字。
使得每条直线上的数字之和都相同。
图中，已经替你填好了3个数字，请你计算星号位置所代表的数字是多少？
![](https://img-blog.csdn.net/20160124154420856)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/兰顿蚂蚁/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 兰顿蚂蚁
问题描述
![](https://img-blog.csdnimg.cn/20200526100857208.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xsX3dhbmc=,size_16,color_FFFFFF,t_70)
兰顿蚂蚁，是于1986年，由克里斯·兰顿提出来的，属于细胞自动机的一种。
平面上的正方形格子被填上黑色或白色。在其中一格正方形内有一只“蚂蚁”。
蚂蚁的头部朝向为：上下左右其中一方。
蚂蚁的移动规则十分简单：
若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；
若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。
规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。
蚂蚁的路线是很难事先预测的。
你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第n步行走后所处的位置。
#### 输入格式
输入数据的第一行是 m n 两个整数（3 < m, n < 100），表示正方形格子的行数和列数。
接下来是 m 行数据。
每行数据为 n 个被空格分开的数字。0 表示白格，1 表示黑格。
接下来是一行数据：x y s k, 其中x y为整数，表示蚂蚁所在行号和列号（行号从上到下增长，列号从左到右增长，都是从0开始编号）。s 是一个大写字母，表示蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示。k 表示蚂蚁走的步数。
#### 输出格式
输出数据为两个空格分开的整数 p q, 分别表示蚂蚁在k步后，所处格子的行号和列号。
#### 样例输入
```
5 6
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
2 3 L 5
```
#### 样例输出
```
1 3
```
#### 样例输入
```
3 3
0 0 0
1 1 1
1 1 1
1 1 U 6
```
#### 样例输出
```
0 0
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/凑算式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 凑算式
```
　　 B 　　 DEF
A + —- + ——–- = 10
　　 C 　　 GHI
```
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/分小组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分小组
9名运动员参加比赛，需要分3组进行预赛。有哪些分组的方案呢？
我们标记运动员为 A,B,C,... I
下面的程序列出了所有的分组方法。
该程序的正常输出为：
```
ABC DEF GHI
ABC DEG FHI
ABC DEH FGI
ABC DEI FGH
ABC DFG EHI
ABC DFH EGI
ABC DFI EGH
ABC DGH EFI
ABC DGI EFH
ABC DHI EFG
ABC EFG DHI
ABC EFH DGI
ABC EFI DGH
ABC EGH DFI
ABC EGI DFH
ABC EHI DFG
ABC FGH DEI
ABC FGI DEH
ABC FHI DEG
ABC GHI DEF
ABD CEF GHI
ABD CEG FHI
ABD CEH FGI
ABD CEI FGH
ABD CFG EHI
ABD CFH EGI
ABD CFI EGH
ABD CGH EFI
ABD CGI EFH
ABD CHI EFG
ABD EFG CHI
..... (以下省略，总共560行)。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/分巧克力/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分巧克力
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力，其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
1. 形状是正方形，边长是整数
2. 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
#### 输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
#### 输出
输出切出的正方形巧克力最大可能的边长。
#### 样例输入：
```
2 10
6 5
5 6
```
#### 样例输出：
```
2
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/分数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分数
1/1 + 1/2 + 1/4 + 1/8 + 1/16 + … 每项是前一项的一半，如果一共有20项，求这个和是多少，结果用分数表示出来。
类似：3/2
当然，这只是加了前2项而已。分子分母要求互质。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/分类计数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分类计数
#### 问题描述
输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字母，多少个数字。
#### 输入格式
输入一行包含一个字符串。
#### 输出格式
输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
#### 样例输入
```
1+a=Aab
```
#### 样例输出
```
1
3
1
```
#### 评测用例规模与约定
对于所有评测用例，字符串由可见字符组成，长度不超过 100。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/分糖果/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分糖果
#### 问题描述
有n个小朋友围坐成一圈。老师给每个小朋友随机发偶数个糖果，然后进行下面的游戏：
每个小朋友都把自己的糖果分一半给左手边的孩子。
一轮分糖后，拥有奇数颗糖的孩子由老师补给1个糖果，从而变成偶数。
反复进行这个游戏，直到所有小朋友的糖果数都相同为止。
你的任务是预测在已知的初始糖果情形下，老师一共需要补发多少个糖果。
#### 输入格式
程序首先读入一个整数N(2<N<100)，表示小朋友的人数。
接着是一行用空格分开的N个偶数（每个偶数不大于1000，不小于2）
#### 输出格式
要求程序输出一个整数，表示老师需要补发的糖果数。
#### 样例输入
```
3
2 2 4
```
#### 样例输出
```
4
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/分配口罩/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分配口罩
某市市长获得了若干批口罩，给定每批口罩的数量，市长要把口罩分配给市内的2所医院。
```
masks = [9090400, 8499400, 5926800, 8547000, 4958200, 4422600, 5751200, 4175600, 6309600, 5865200, 6604400, 4635000, 10663400, 8087200, 4554000]
```
由于物流限制，每一批口罩只能全部分配给其中一家医院。
市长希望2所医院获得的口罩总数之差越小越好。
请你计算这个差最小是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/切面条/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 切面条
一根高筋拉面，中间切一刀，可以得到2根面条。
如果先对折1次，中间切一刀，可以得到3根面条。
如果连续对折2次，中间切一刀，可以得到5根面条。
那么，连续对折10次，中间切一刀，会得到多少面条呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/前缀判断/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 前缀判断
如下的代码判断 needle_start指向的串是否为haystack_start指向的串的前缀，如不是，则返回NULL。
比如："abcd1234" 就包含了 "abc" 为前缀
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/剪格子/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 剪格子
#### 问题描述
如下图所示，3 x 3 的格子中填写了一些整数。
```
+--*--+--+
|10* 1|52|
+--****--+
|20|30* 1|
*******--+
| 1| 2| 3|
+--+--+--+
```
我们沿着图中的星号线剪开，得到两个部分，每个部分的数字和都是60。
本题的要求就是请你编程判定：对给定的m x n 的格子中的整数，是否可以分割为两个部分，使得这两个区域的数字和相等。
如果存在多种解答，请输出包含左上角格子的那个区域包含的格子的最小数目。
如果无法分割，则输出 0。
#### 输入格式
程序先读入两个整数 m n 用空格分割 (m,n<10)。
表示表格的宽度和高度。
接下来是n行，每行m个正整数，用空格分开。每个整数不大于10000。
#### 输出格式
输出一个整数，表示在所有解中，包含左上角的分割区可能包含的最小的格子数目。
#### 样例输入1
```
3 3
10 1 52
20 30 1
1 2 3
```
#### 样例输出1
```
3
```
#### 样例输入2
```
4 3
1 1 1 1
1 30 80 2
1 1 1 100
```
#### 样例输出2
```
10
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/剪邮票/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 剪邮票
如图
![](https://img-blog.csdnimg.cn/20190313183756434.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N5bHZpYV9XdTUx,size_16,color_FFFFFF,t_70)
有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）比如
![](https://img-blog.csdnimg.cn/20190313183806622.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N5bHZpYV9XdTUx,size_16,color_FFFFFF,t_70)，
![](https://img-blog.csdnimg.cn/2019031318382071.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1N5bHZpYV9XdTUx,size_16,color_FFFFFF,t_70)中，粉红色所示部分就是合格的剪取。
请你计算，一共有多少种不同的剪取方法。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/加法变乘法/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 加法变乘法
#### 题目描述：
我们都知道：1+2+3+ … + 49 = 1225
现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015
比如：
1+2+3+…+1011+12+…+2728+29+…+49 = 2015 就是符合要求的答案。
请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/单词分析/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 单词分析
#### 问题描述
小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。
现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。
#### 输入格式
输入一行包含一个单词，单词只由小写英文字母组成。
#### 输出格式
输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪
个。如果有多个字母出现的次数相等，输出字典序最小的那个。
第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。
#### 样例输入
```
lanqiao
```
#### 样例输出
```
a 2
```
#### 样例输入
```
longlonglongistoolong
```
#### 样例输出
```
o 6
```
#### 评测用例规模与约定
对于所有的评测用例，输入的单词长度不超过 1000。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/压缩变换/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 压缩变换
#### 问题描述
小明最近在研究压缩算法。
他知道，压缩的时候如果能够使得数值很小，就能通过熵编码得到较高的压缩比。
然而，要使数值很小是一个挑战。
最近，小明需要压缩一些正整数的序列，这些序列的特点是，后面出现的数字很大可能是刚出现过不久的数字。对于这种特殊的序列，小明准备对序列做一个变换来减小数字的值。
变换的过程如下：
从左到右枚举序列，每枚举到一个数字，如果这个数字没有出现过，刚将数字变换成它的相反数，如果数字出现过，则看它在原序列中最后的一次出现后面（且在当前数前面）出现了几种数字，用这个种类数替换原来的数字。
比如，序列(a1, a2, a3, a4, a5)=(1, 2, 2, 1, 2)在变换过程为：
a1: 1未出现过，所以a1变为-1；
a2: 2未出现过，所以a2变为-2；
a3: 2出现过，最后一次为原序列的a2，在a2后、a3前有0种数字，所以a3变为0；
a4: 1出现过，最后一次为原序列的a1，在a1后、a4前有1种数字，所以a4变为1；
a5: 2出现过，最后一次为原序列的a3，在a3后、a5前有1种数字，所以a5变为1。
现在，给出原序列，请问，按这种变换规则变换后的序列是什么。
#### 输入
输入第一行包含一个整数n，表示序列的长度。
第二行包含n个正整数，表示输入序列。
#### 输出
输出一行，包含n个数，表示变换后的序列。
#### 输入例子 1
```
5
1 2 2 1 2
```
#### 输出例子 1
```
-1 -2 0 1 1
```
#### 输入例子 2
```
12
```
#### 输出例子 2
```
-1 0 -2 -3 1 1 2 2 0 0 2 2
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/取数位/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 取数位
求1个整数的第k位数字有很多种方法。
以下的方法就是一种。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/取球博弈/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 取球博弈
#### 问题描述
两个人玩取球的游戏。
一共有N个球，每人轮流取球，每次可取集合{n1,n2,n3}中的任何一个数目。
如果无法继续取球，则游戏结束。此时，持有奇数个球的一方获胜。如果两人都是奇数，则为平局。
假设双方都采用最聪明的取法，第一个取球的人一定能赢吗？
试编程解决这个问题。
#### 输入
第一行3个正整数n1 n2 n3，空格分开，表示每次可取的数目 (0<n1,n2,n3<100)
第二行5个正整数x1 x2 … x5，空格分开，表示5局的初始球数(0<xi<1000)
#### 输出
一行5个字符，空格分开。分别表示每局先取球的人能否获胜。
能获胜则输出+，
次之，如有办法逼平对手，输出0，
无论如何都会输，则输出 -
#### 输入例子 1
```
1 2 3
1 2 3 4 5
```
#### 输出例子 1
```
+ 0 + 0 -
```
#### 输入例子 2
```
1 4 5
10 11 12 13 15
```
#### 输出例子 2
```
0 - 0 + +
```
#### 输入例子 3
```
2 3 5
7 8 9 10 11
```
#### 输出例子 3
```
+ 0 0 0 0
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/取球游戏/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 取球游戏
今盒子里有n个小球，A、B两人轮流从盒中取球，每个人都可以看到另一个人取了多少个，也可以看到盒中还剩下多少个，并且两人都很聪明，不会做出错误的判断。
我们约定：
每个人从盒子中取出的球的数目必须是：1，3，7或者8个。轮到某一方取球时不能弃权！
A先取球，然后双方交替取球，直到取完。
被迫拿到最后一个球的一方为负方（输方）
请编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？
程序运行时，从标准输入获得数据，其格式如下：
先是一个整数n(n<100)，表示接下来有n个整数。然后是n个整数，每个占一行（整数<10000），表示初始球数。
程序则输出n行，表示A的输赢情况（输为0，赢为1）。
例如，用户输入：
```
4
1
2
10
18
```
则程序应该输出：
```
0
1
1
0
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/古堡算式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 古堡算式
福尔摩斯到某古堡探险，看到门上写着一个奇怪的算式：
ABCDE * ? = EDCBA
他对华生说：“ABCDE应该代表不同的数字，问号也代表某个数字！”
华生：“我猜也是！”
于是，两人沉默了好久，还是没有算出合适的结果来。
请你利用计算机的优势，找到破解的答案。
把 ABCDE 所代表的数字写出来。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/史丰收速算/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 史丰收速算
史丰收速算法的革命性贡献是：从高位算起，预测进位。不需要九九表，彻底颠覆了传统手算!
速算的核心基础是：1位数乘以多位数的乘法。
其中，乘以7是最复杂的，就以它为例。
因为，1/7 是个循环小数：0.142857...，如果多位数超过 142857...，就要进1
同理，2/7, 3/7, ... 6/7 也都是类似的循环小数，多位数超过 n/7，就要进n
下面的程序模拟了史丰收速算法中乘以7的运算过程。
乘以 7 的个位规律是：偶数乘以2，奇数乘以2再加5，都只取个位。
乘以 7 的进位规律是：
```
满 142857... 进1,
满 285714... 进2,
满 428571... 进3,
满 571428... 进4,
满 714285... 进5,
满 857142... 进6
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/合并检测/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 合并检测
新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准 备给大量民众进病毒核酸检测。
然而，用于检测的试剂盒紧缺。为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k 个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k 个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明 至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看， 如果检测前 k−1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中 不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用 了 k + 1 个试剂盒完成了 k 个人的检测。
A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能最节省试剂盒？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/后缀表达式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 后缀表达式
#### 问题描述
给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1,A2,··· ,AN+M+1，小明想知道在所有由这 N 个加号、M 个减号以及 N + M +1 个整数凑出的合法的 后缀表达式中，结果最大的是哪一个？
请你输出这个最大的结果。 例如使用1 2 3 + -，则 “2 3 + 1 -” 这个后缀表达式结果是 4，是最大的。
#### 输入格式
第一行包含两个整数 N 和 M。 第二行包含 N + M + 1 个整数 A1,A2,··· ,AN+M+1。
#### 输出格式
输出一个整数，代表答案。
#### 样例输入
```
1 1
1 2 3
```
#### 样例输出
```
4
```
#### 评测用例规模与约定
对于所有评测用例，0≤ N,M ≤100000，−10^9 ≤ Ai ≤10^9。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/哪天返回/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 哪天返回
小明被不明势力劫持，后莫名其妙被扔到x星站再无问津。
小明得知每天都有飞船飞往地球，但需要 108 元的船票，而他却身无分文，他决定在 x 星战打工。
好心的老板答应包食宿，第 1 天给他 1 元钱，并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。
请计算一下，小明在第几天就能凑够 108 元，返回地球。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/啤酒和饮料/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 啤酒和饮料
啤酒每罐2.3元，饮料每罐1.9元。小明买了若干啤酒和饮料，一共花了82.3元。
我们还知道他买的啤酒比饮料的数量少，请你计算他买了几罐啤酒。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/四平方和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 四平方和
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
```
5 = 0^ 2 + 0^ 2 + 1^ 2 + 2^2
7 = 1^ 2 + 1^ 2 + 1^ 2 + 2^2
（^符号表示乘方的意思）
```
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
```
0 <= a <= b <= c <= d
```
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
```
5
```
则程序应该输出：
```
0 0 1 2
```
再例如，输入：
```
12
```
则程序应该输出：
```
0 2 2 2
```
再例如，输入：
```
773535
```
则程序应该输出：
```
1 1 267 838
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/回文日期/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 回文日期
#### 问题描述
2020 年春节期间，有一个特殊的日期引起了大家的注意：2020年2月2日。因为如果将这个日期按“yyyymmdd” 的格式写成一个8 位数是20200202，恰好是一个回文数。我们称这样的日期是回文日期。
有人表示20200202 是“千年一遇” 的特殊日子。对此小明很不认同，因为不到2年之后就是下一个回文日期：20211202 即2021年12月2日。
也有人表示20200202 并不仅仅是一个回文日期，还是一个ABABBABA型的回文日期。对此小明也不认同，因为大约100 年后就能遇到下一个ABABBABA 型的回文日期：21211212 即2121 年12 月12 日。算不上“千年一遇”，顶多算“千年两遇”。
给定一个8 位数的日期，请你计算该日期之后下一个回文日期和下一个ABABBABA型的回文日期各是哪一天。
#### 输入格式
输入包含一个八位整数N，表示日期。
#### 输出格式
输出两行，每行1 个八位数。第一行表示下一个回文日期，第二行表示下
一个ABABBABA 型的回文日期。
#### 样例输入
```
20200202
```
#### 样例输出
```
20211202
21211212
```
#### 评测用例规模与约定
对于所有评测用例，10000101 ≤ N ≤ 89991231，保证N 是一个合法日期的8位数表示。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/圆周率/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 圆周率
数学发展历史上，圆周率的计算曾有许多有趣甚至是传奇的故事。其中许多方法都涉及无穷级数。
图中所示，就是一种用连分数的形式表示的圆周率求法。
![](https://img-blog.csdnimg.cn/20210128181357213.png)
下面的程序实现了该求解方法。实际上数列的收敛对x的初始值 并不敏感。
结果打印出圆周率近似值（保留小数点后4位，并不一定与圆周率真值吻合）。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/地宫取宝/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 地宫取宝
X 国王有一个地宫宝库，是 n×m 个格子的矩阵，每个格子放一件宝贝，每个宝贝贴着价值标签。
地宫的入口在左上角，出口在右下角。
小明被带到地宫的入口，国王要求他只能向右或向下行走。
走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。
当小明走到出口时，如果他手中的宝贝恰好是 k 件，则这些宝贝就可以送给小明。
请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这 k 件宝贝。
#### 输入格式
第一行 3 个整数，n,m,k，含义见题目描述。
接下来 n 行，每行有 m 个整数 Ci 用来描述宝库矩阵每个格子的宝贝价值。
#### 输出格式
输出一个整数，表示正好取 k 个宝贝的行动方案数。
该数字可能很大，输出它对 1000000007 取模的结果。
#### 数据范围
```
1≤n,m≤50,
1≤k≤12,
0≤Ci≤12
```
#### 输入样例1：
```
2 2 2
1 2
2 1
```
#### 输出样例1：
```
2
```
#### 输入样例2：
```
2 3 2
1 2 3
2 1 5
```
#### 输出样例2：
```
14
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/垒骰子/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 垒骰子
赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。
经过长期观察，atm 发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！
我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。
假设有 m 组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。
atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
由于方案数可能过多，请输出模 $10^9 + 7$ 的结果。
不要小看了 atm 的骰子数量哦～
#### 输入格式
第一行两个整数 n m
n表示骰子数目
接下来 m 行，每行两个整数 a b ，表示 a 和 b 数字不能紧贴在一起。
#### 输出格式
一行一个数，表示答案模 10^9 + 7 的结果。
#### 样例输入
```
2 1
1 2
```
#### 样例输出
```
544
```
#### 数据范围
```
对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10^9, m <= 36
```
#### 资源约定：
峰值内存消耗 < 256M
CPU消耗 < 2000ms
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/堆的计数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 堆的计数
#### 题目描述
我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。
假设N个节点的权值分别是1~N，你能求出一共有多少种不同的小根堆吗？
例如对于N=4有如下3种：
```
1
/ \
2 3
/
4
1
/ \
3 2
/
4
1
/ \
2 4
/
3
```
由于数量可能超过整型范围，你只需要输出结果除以1000000009的余数。
#### 输入格式
一个整数N。
对于40%的数据，1 <= N <= 1000
对于70%的数据，1 <= N <= 10000
对于100%的数据，1 <= N <= 100000
#### 输出格式
一个整数表示答案。
#### 输入样例
```
4
```
#### 输出样例
```
3
```
#### 资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/复数幂/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 复数幂
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 "实部±虚部i" 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。
(2+3i)^2 写成: -5+12i，
(2+3i)^5 写成: 122-597i
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/外卖店优先级/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 外卖店优先级
#### 问题描述
“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有一个优先级，初始时 (0 时刻) 优先级都为 0。
每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。
如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果优先级小于等于 3，则会被清除出优先缓存。
给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优先缓存中。
#### 输入格式
第一行包含 3 个整数 N、 M 和 T。
以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到一个订单。
#### 输出格式
输出一个整数代表答案。
#### 样例输入
```
2 6 6
1 1
5 2
3 1
6 2
2 1
6 2
```
#### 样例输出
```
1
```
#### 样例解释
6 时刻时， 1 号店优先级降到 3，被移除出优先缓存； 2 号店优先级升到 6，加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
#### 评测用例规模与约定
```
对于 80% 的评测用例， 1 ≤ N; M; T ≤ 10000。
对于所有评测用例， 1 ≤ N; M; T ≤ 100000， 1 ≤ ts ≤ T， 1 ≤ id ≤ N。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/大数乘法/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 大数乘法
对于32位字长的机器，大约超过20亿，用int类型就无法表示了，我们可以选择int64类型，但无论怎样扩展，固定的整数类型总是有表达的极限！如果对超级大整数进行精确运算呢？一个简单的办法是：仅仅使用现有类型，但是把大整数的运算化解为若干小整数的运算，即所谓：“分块法”。
![](https://img-blog.csdn.net/20160125091111485)
上图表示了分块乘法的原理。可以把大数分成多段（此处为2段）小数，然后用小数的多次运算组合表示一个大数。可以根据int的承载能力规定小块的大小，比如要把int分成2段，则小块可取10000为上限值。注意，小块在进行纵向累加后，需要进行进位校正。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/大臣的旅费/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 大臣的旅费
#### 问题描述
很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。
为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。
J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。
聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。
J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？
#### 输入格式
输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数
城市从1开始依次编号，1号城市为首都。
接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）
每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。
#### 输出格式
输出一个整数，表示大臣J最多花费的路费是多少。
#### 样例输入1
```
5
1 2 2
1 3 1
2 4 5
2 5 4
```
#### 样例输出1
```
135
```
#### 输出格式
```
大臣J从城市4到城市5要花费135的路费。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/大衍数列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 大衍数列
中国古代文献中，曾记载过“大衍数列”, 主要用于解释中国传统文化中的太极衍生原理。
它的前几项是：```0、2、4、8、12、18、24、32、40、50 …```
其规律是：对偶数项，是序号平方再除2，奇数项，是序号平方减1再除2。
以下的代码打印出了大衍数列的前 100 项。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/夺冠概率/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 夺冠概率
足球比赛具有一定程度的偶然性，弱队也有战胜强队的可能。
假设有甲、乙、丙、丁四个球队。根据他们过去比赛的成绩，得出每个队与另一个队对阵时取胜的概率表:
```
甲 乙 丙 丁
甲 - 0.1 0.3 0.5
乙 0.9 - 0.7 0.4
丙 0.7 0.3 - 0.2
丁 0.5 0.6 0.8 -
```
数据含义：甲对乙的取胜概率为0.1，丙对乙的胜率为0.3，...
现在要举行一次锦标赛。双方抽签，分两个组比，获胜的两个队再争夺冠军。（参见【1.jpg】）
请你进行10万次模拟，计算出甲队夺冠的概率。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/奇妙的数字/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 奇妙的数字
小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。
你能猜出这个数字是多少吗？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/奇怪的分式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 奇怪的分式
上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：
1/4 乘以 8/5
小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45
![](https://images2015.cnblogs.com/blog/1139769/201704/1139769-20170406155423800-1872161918.png)
老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！
对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？
请写出所有不同算式的个数（包括题中举例的）。
显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。
但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/奇怪的比赛/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 奇怪的比赛
某电视台举办了低碳生活大奖赛。题目的计分规则相当奇怪：
每位选手需要回答10个问题（其编号为1到10），越后面越有难度。答对的，当前分数翻倍；答错了则扣掉与题号相同的分数（选手必须回答问题，不回答按错误处理）。
每位选手都有一个起步的分数为10分。
某获胜选手最终得分刚好是100分，如果不让你看比赛过程，你能推断出他（她）哪个题目答对了，哪个题目答错了吗？
如果把答对的记为1，答错的记为0，则10个题目的回答情况可以用仅含有1和0的串来表示。例如：0010110011 就是可能的情况。
你的任务是算出所有可能情况。每个答案占一行。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/奖券数目/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 奖券数目
有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。
虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/子串分值/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 子串分值
#### 题目描述
对于一个字符串 S，我们定义 S 的分值 f(S)为 S 中出现的不同的字符个数。
例如f(“aba”)=2，f(“abc”)=3，f(“aaa”)=1。
现在给定一个字符串 S[0…n−1]（长度为 n），请你计算对于所有S的非空子串S[i…j] (0≤i≤j<n)，f(S[i…j]) 的和是多少。
#### 输入格式
输入一行包含一个由小写字母组成的字符串 S。
#### 输出格式
输出一个整数表示答案。
#### 输入样例
```
ababc
```
#### 输出样例
```
21
```
样例解释
```
子串 f值
a 1
ab 2
aba 1
abab 0
ababc 1
b 1
ba 2
bab 1
babc 2
a 1
ab 2
abc 3
b 1
bc 2
c 1
```
数据范围
```
对于 20% 的评测用例，1 ≤ n ≤ 10 1 ≤ n ≤ 101≤n≤10；
对于 40% 的评测用例，1 ≤ n ≤ 100 1 ≤ n ≤ 1001≤n≤100；
对于 50% 的评测用例，1 ≤ n ≤ 1000 1 ≤ n ≤ 10001≤n≤1000；
对于 60% 的评测用例，1 ≤ n ≤ 10000 1 ≤ n ≤ 100001≤n≤10000；
对于所有评测用例，1 ≤ n ≤ 100000 1 ≤ n ≤ 1000001≤n≤100000。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/字串排序/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字串排序
#### 问题描述
小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。
在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。
例如，对于字符串 lan 排序，只需要 1 次交换。对于字符串 qiao 排序，总共需要 4 次交换。
小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 V 次交换，可是他忘了把这个字符串记下来，现在找不到了。
请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对该串的字符排序，正好需要 V 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。请注意字符串中可以包含相同的字符。
#### 输入格式
输入的第一行包含一个整数V，小蓝的幸运数字。
#### 输出格式
题面要求的一行字符串。
#### 样例输入
```
4
```
#### 样例输出
```
bbaa
```
#### 样例输入
```
100
```
#### 样例输出
```
jihgfeeddccbbaa
```
#### 评测用例规模与约定
```
对于 30% 的评测用例， 1 ≤ V ≤ 20。
对于 50% 的评测用例， 1 ≤ V ≤ 100。
对于所有评测用例， 1 ≤ V ≤ 10000。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/字母组串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字母组串
由A , B , C A,B,CA,B,C这3个字母就可以组成许多串。
比如："A AA"，"A B ABAB"，"A B C ABCABC"，"A B A ABAABA"，"A A C B B AACBBAACBB"……现在，小明正在思考一个问题：如果每个字母的个数有限定，能组成多少个已知长度的串呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/字母阵列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字母阵列
仔细寻找，会发现：在下面的8x8的方阵中，隐藏着字母序列：“LANQIAO”。
```
SLANQIAO
ZOEXCCGB
MOAYWKHI
BCCIPLJQ
SLANQIAO
RSFWFNYA
XIFZVWAL
COAIQNAL
```
我们约定: 序列可以水平，垂直，或者是斜向；并且走向不限（实际上就是有一共8种方向）。
上面一共有4个满足要求的串。
下面有一个更大的（100x100）的字母方阵。
你能算出其中隐藏了多少个“LANQIAO”吗？
我就把这些东西放在了txt文件里
```
FOAIQNALWIKEGNICJWAOSXDHTHZPOLGYELORAUHOHCZIERPTOOJUITQJCFNIYYQHSBEABBQZPNGYQTCLSKZFCYWDGOAIADKLSNGJ
GSOZTQKCCSDWGUWAUOZKNILGVNLMCLXQVBJENIHIVLRPVVXXFTHQUXUAVZZOFFJHYLMGTLANQIAOQQILCDCJERJASNCTLYGRMHGF
TSDFYTLVIBHKLJVVJUDMKGJZGNNSTPVLCKTOFMUEUFSVQIAUVHNVFTGBDDARPKYNNCUOYUAZXQJNOEEYKLFRMOEMHUKJTPETHLES
FKVINSLWEVGAGMKVFVIUBMYOIAFHLVNKNTYKTZWVXQWRWIGPENFXYDTKRVPKRTHMGHVYOCLDCKMEKRLGEKBYUCLOLYPAKPFSOREH
KWPUOLOVMOFBIXYACWRDYBINTMPASPCEOKHXQIGBQQMCEOIVULIEOPFSCSIHENAJCVDPJDOIWIIULFDNOZOFVAMCABVGKAKCOZMG
XWMYRTAFGFOCNHLBGNGOXPJSTWLZUNNAGIRETGXFWAQSSJPFTQAXMTQWMZWYVEPQERKSWTSCHSQOOBGXAQTBCHOEGBDVKGWJIFTG
ZWWJEIISPLMXIMGHOOGDRZFTGNDDWDWMNUFWJYJGULPHNUFSAQNNIUVAAFZIAZKFXXNWCEABGJAUMGYEIEFVQXVHHHEDYUITRCQB
XZHDPZQTOBECJVBZLACVXACZEDYOGVAVQRNWEOWGRAQYUEUESTEDQTYJUTEFOOITSHDDZHONJGBRCWNEQLZUTBNQIADKNFIOMWZR
EBFKCVNLURZSNPOLTISRPDTNUMCDGKTYRGIOVEPTUTSBAWQKWWEUWIWHAANUZUADGZEATZOQICWFUJTWNZDBKLQNELWVTBNDLNFH
PESISEATZNCDFRMXBQUKBFTIGYSFCWVHPMSUSDKPSCOMVLDOHYQVFHAJKRDTAVLIMNZBZSMLMRTLRPSLAHXDBASDMWAAYBPYVJZF
SCCWYHLQOUKBMCEYENQNJXFOMOOJMTKDSHJJOHDKEGATFZHGWJJAZJROWHAZUFGEQKPYXLCAAXHHQBDALPYUDWZQHBASBBCFGQCQ
ZKNXUBRYZVSPQHOVLAEUAUITMPWXNXJQVIBJVBCSVXKWFAFRPRWOLYVSDVTGGOFFMNQJZOBUDJLFHJTCYMPNOBHQJHGKLIKLZMLA
POCKVEQXUAVHERIAQLGJHYOOVOMTXQFRTBFSETOZICPCHZHFBWNESVJJLSVSVOOGYYABFESWNWDNYBGBNAKRCFQMTCUMIFTESVIN
JCAULIQRYUMAMAOVVWSEUTMECXSDTONRMMROQUISYEURSAYNZUVOPXLIFBDOHPXMABBLEQZGLJXQJOEYYRRRCFTEZQAOIWKRJQDL
ZNUUDWZXZZURPMHGXQGNQBIQWWNERZWULSAPIBODBFFQQIHEQKCKLJYQNXQUTAAYGRBXSLLQNOQPZJEWHETQHPXJANMJFOHINWOW
KJGAWWFSVIZHFNUWBLWYVPIWAEICCAHOEIWRADSLOZGPSVGPUBUUQAVYCHOIGINKYKJABWAQCZCXOBKTNJZQRHLUFKQLACAAOIWJ
SIKWLXQHKDFJVGBVXWDWJKUSFRQRTDJYQMNFOQQALHRLMHSDMCFLAOVKDMTKMTPVTLAZLYJNJXZCFRHHSDIXYUUSVIMIICLUJHFW
JHWUSMCFYHPIXHAPBBSHYDQCKVGQFTENLVERFVOVDCLSTQFUSEPUMTFODLZLYQXDOXAEPONIQWTDWSAWBNSZYACGSJQSHAUMIKXT
MVBNFXMFNPAYSODPXEAYNRKTEZJWMUACSIUYPIORUFPMXAOZZJPJXPFLNSKNIAMETMOVULZPQIJJIRCSYQXOEVRHCNACSBRHKYNW
KGKBTBHGWKVJYZCOVNSKUREKZEIWVLOHAMUAYKLUGHEUESICBZAHURNTJAECTHRNKSIJQFIPVZANSZYSPJWHPKHCAPEYWNXUYQSD
RRRFYQFIQSWYRQTSNGNUFOBMSLGAFWPJGYEHGASFKTJCCZPXFIQLSXNKNWCYVTETOAPCOZJNHEWOCCAWVDEZUQCLLAVUQJJTQCKJ
NMBKMUENVGXXVMQCLXPJDQIQCFWYADIFDSGINGZDJYHPUPXVRMWDIPJRWPNRYOFGYYPEAVKDEMLYRRRMNCRQXPTDSQIVKKGJWDEF
SBAEKIFZCKDOMIQKBDWVQGBYWPDIBOLQUGAQRXLJDAZMXVZXYSNWEWTNZKYREMBEUHOTFOCKEJSXCMUBCKXNGQXTQJRCRCLWJTOI
YXBFBIBRAAFNPKBLTSMCFERZURZNWHMOEHIHNQTBWXNPJGIDYDPRGEWACCBULJRACOFLANQIAOIHMYCNQHVKXSIGAMWAHUSNBBTD
QDGPTRONXHAZWOUPNBFJFEWAMFZUQZFDKAPNJUBQPWBPYGPZHKUDZZDLCCWHGAUKJCSLLFWGPYJKJQBNLCZESOGXXSQCVVKVRVAW
NXPGQOUEFLUZHHSAODIWEPZLXVQLYGVOOVCCREDJZJOMCSCFFKEIEAVCTPUZOWNOLJHGBJHJFBFFORGXOXXFOCAGBWEFCIDEKDLB
PTXSUINQAJURNFQPMMSPLZTQAHCIOFJUEFFZGIHTSJNIEXQLLHRQUXXLLORJEHGQJOXSLIAVFPEJNGMMVAXDDMPXLOSTRLLFLYRM
JQNCLENGTROIKDWBMXRNJYPGZRQOREPJJPTXKVVKPYYZENEOIQKZOPXAYGFXORXRIDGATHMZFDJIOIOKVDJBHSXQMYCBYFGXWHLH
CITGTILGPGBHZMNWWHXEFPGDPJUVFBJKAQWACZHPRPJYCOLGZTBDCVHNRSUAJUQAWAPMQJDQIFPZQZEONWHIYKMXDZOMVETEFJRB
RDOTIDCFEESOKYPYCGQQKOGPMGJRITSVTKOKDSXLRLJRRHNFRFXCMDNQMCEGZFJWHZOAFBQXXPXNBSWTSUYPAWQRHAUGLNPBRSJT
HOWRIUGMOQTUYIHDWJRFBWWKWYKCICSVBVKTBIIWGFSVIFCTUKIHHUUISCOTEOYRWQXTAEBXQQOLLMOALNIYVCCHNSWIKHMYYNZO
OFRIYYXPPSRTPAYMUJSSDILKIZAYSEIOLANQIAOVKARDPGVFCSYBSNHAPGTIKLAWTTKOEADWRLAACAAFYTBTNSGFTYLYUHJXBMMA
NJFTMLUIBKDPWBXQOMBVQXCZOIREHRSZCSJOIVBXWQIBUTYBQNTZRVROHGOIZYAJWXLEATLOZJIKJMIHSLGSVTCXJWIOOGWSERRQ
DBQJNGBLRIYFIKHBEYOZQBOAGGNIZKFDHWXCFNJLBQXVLHIQNIBZSDLTTRERHNWCMLJCVBBGGAQTPUQHIRABXPQSYGSDVMBNNDFG
KPLFUYXHYGOCZPPXMWCZYNKCYBCRZVKFBHQXPGPBZFTTGEPQTJMOFHAYSQQZDMQECGXOXADYHNNXUKNBXZBYHBOULXNBJZKIZREF
LVHAMSNXJOCVRPVGJUWXFVOCUCLCZDXRPBBDRLRAVVNLOZWOHWMXYSNMXAKJYWYGILNGUJGIPKAUDVANZLFWKUWWUSQYBRCBVDIJ
QCXPLOTPPGXCUZOUSSTXHVMLHVMJTUSSOPLRKEBQSGWNGVHKANVZWYQHSHLIPWSYCPKTUKPMWPLVFLLAHXZQANFXHFNYHIQVIOYN
ZPTJJCBHXPSUPOMNRVCKXSUFCNRCRNCPTPGIDQOEQUDFNUNMJPOEKVIMUJAJZOUKMAFSLDWYMCHTSNJYUDJAHQOIXPYSRHVAFFCR
DCGMEEWXWMNOSSJNIZCINRHENPPPCYVFWYCONOPKXMFZXXIHNXIGAHAMHSBRESOETGVXWDNQLGCEOUDDJXHQIVCHRNKBFFEWILGY
SOAIQNALXRBSGAQIDQVMVDKVZCPMJNXKXRXPFZAUVQPBHHQKTPDSQROLQTUGMFQRWGVEWCYPDYDZGNNNUFKJUEHJKPLIQNRQYXHU
GKGWUCJXUKAEHLRLNDFUQPSJAZTVJRXWXQVBMRJXULEMJJPDCVTOWVFDBVLSBHZRRQUVMUQYKTJCLSGGHGCPHPHMWYAECLJIZUWV
QQNKPQRJMSOCEAYDNKPHVEGKAGCKAPDXTGVXULHUXHJPDXCSKQTCJENVTZTMRUENCSWHBEORALSREBWAJEMQDXMRKGHJGICDHKHY
YNSDSWDRLBBFUFVVICMGUCGBSVDLJNXGKXNFGVLKAVBJRRRUHKRXTPBJAKIEBAVMDIOJLIUDABCGNPNJIYBCXMOOWKRPHPYSWRDC
BORWTNBISSLTVKBRTLWKRNCEDCNEGCIYJIPDICFAVNOISYAHWBLGMNFKXZYTTWJOBEPNMSJEJMHXVPGOJOLQQQVXFGEULANQIAOD
OQETOJHCZXGTUKIWGMEVVMXCURISUOFQSAWZWDMZWVYHZMPEIMWKJDGERODVVUXYRTYLCRGYQQOIOFZSSZRAIESWBQOAIQNALJNR
HEYWHPLLPCUEOCBAOWGAYEJZQJHLVNMVQNSQQGGUBOIMDPFLOVSQGBLYAMBRYJDVOXOQINLJAVYALAKHPKOYNKGXIISSJNGKHYMS
IQVRYKXCUFIRNENEXFJTMOTJWYXSMTDHHPRHWIXETWVVIXZELKLLWRWQYGBCGJNYSUQEFCOUDNIJMLJNLAWSYJGULKBCFPYVSSMW
WQHGWRQFWFOTGPBBSJBDUKOMBXNRPIMCGPGVZFADWTBVIEMVTBXVAFQDDMJALCOMZTXUFFKBQQZDFAMTFWEXTHBKNWRLUVITQXLN
OPPJQKNGHWWPENVQIABJCQNKXNPWOWRFEOKQPQLANQIAORGGOLAYCEGZBHZVLPBERWYIJNJUNXKULUQOJLTNRDZDEYWEMYCHJLLB
LJISOAQLXJEFXVTOZSICOLQIJEXUANJWIFSIMGUQWHBXUDWOEILYFUZTGDZDSPLZPDPXBLFAXLEFQFEPDSJQWEQMXKKHCXHMSATM
UMUJENPBYKZLWAJAXJKDIYCBREBPOETQHMRHLKSEZUIPRGWIZDDQLSJAPKPBWMJMPZWLNFLFCQOCDBMLIHIYCXUJLFLPZVGWBKMY
WHZJLKEWUPETVUREKVKCLBNYFLWCERVIPUDINNWGQTUHWXCTDVTMYATYUZLMVLOHKBOGIZCQDOWFBCWJAVUXYUEVRKPOXCKHAWZC
RPLNLCUHJRADHJNSDPZXIKXGUKEJZCFJQASVUBSNLXCJXVCJZXGMRYRLOBCNGPDUJQVEFKMYHNZGZOAIQNALQDHTBWJXPKJLFXJY
MKCEZEDAFGSOCORWJGMOKWPVVBVDYZDZHPXFWJBDELHPGOQHMBAHUUUJMGXAEKZCTQTBXNVYUIQUVZGXSKQXJWRUPSFIJDYIAORC
GKFKQNXPJWOPPBTUKTHUBIROSYOVFEMJBRREWICJPCIOSTWPAUSKTRQULXPWRSXHSRYBCWYCYOTCTPFSQLDIILIGMEVZKYSOYRPH
SFDSCSMLLNARCCGCBJOGZAEQTGNGSFAQIXLPDBSWZDTYVASYYPVBRFBTIAGGWONGSVKCJDBBLYKAIOXUATGMALZXFOHZFTXALCFU
CUSSTLCRYPDTFSFJFENKJWTEBOBEPLSNXLALQWCKSLVMZQDJITHZKVCCQXTEXOSVAUFYAZXJUOAPPVEEWOIIMOSZZMCOQBRUXWKG
PDOFSCKKJJTRYRWGLEZODQTJSIMXIAOLNMLPHBAYLPTTLPYWILSEIIQVSXNHIJEORVCNJHYXRBIZZJTADGMRTSXVRXYGVQQNUEIC
IHNJOQXUXTXFPALCHOELNVMWDWQTEARUKPIFWXJSMWZLMNLAODUTKNZDYRFRLGBLIBGIBXJBOYMLYLANQIAORORYKSJPOOOAMVRN
IWIUHLYJKTQGVJBDPROSRGZUFITDIBCDPICNEFIGHWGSROWBYKUCLCQYLJXLHLXSCTJWKDLHHMLDBZCVDKPXYYASHUUMUJMVSXAD
GXOYXQFEBFIEJJLHBNGSYALOUXNQBXXZAAZJXENJJVVGFVHOTKSLEGLJVSJCQHSSZFEIOGBOGWSPIRENQAAWRQFBEFEXBKGMSTRC
PYIANSGMNKBCDPHWDUPKICQEUDNZPNGRUJYSZIRLXGXXITAFBCANGDLVAQLDPVTJNSAUZMBBNOBBOERSHQIOLBVTSPPJKVCMXUBS
IKMDIYSNCJZKJKJQMTIKEPRUNAHJUSWJHSLWIVWHYAYLOIOGSZVWKQWXZDBPHWZRAIPMXDJHBIISVJWVEVZAEGAKCYYMNZARBZPC
DLDFVQDFDMVHYVOWEKMFKWUXLTPWIVKPRZZXOLMDAPAIQEKJHCHYAGJDBOFWDGNEGQGOOKWSKLTLREMGGTVJFHAIBCQKNZVRCZYS
FBQASGNCCBBGNKJHCDBTGBIIWKMPHDABKEWDEPYEAVKNMPATUZZUOEHGUGAZNECSGUCIIJPMMRAMTVADMTCRJCBWDLWWFNFOWMVZ
XFJFBGDAVGGAIZHAUIYENDZTRUWHPQUFWCHOXNCWYNAWVPLBLNQKQDTKQQKXNFXCTBGRWUZFHNRBDNLNKQVOLLGBBJQIYOBCEIKO
CURAGWXMLYBSIZLAXFONZZMQMRNNSRQKRHQGFGZUTLONAYRKSSOWAMKZBSGOOYQDPTBHGPBNQEDCZHRTOXREOFJEKJVIZXZBCJPN
KGYBZTZRKOGBETJRUWRNUCIFKIMCZGYTZLCZYGCGKVZRJIFZQIQPTCPPUHYWIXBOFFGSGSAIMNGKKUUROAVNJUQQNSWJRZIZEHAF
DDAOBVCPOVODVJFLSNPJXHWQBHILWZAHQQMTQASNADZLZNXJLJMFCOUWOZJCMVVTYCKTUBABWLCEBNYWAMOLNBQQYBRUJCQCZALE
TVVRPMYFIKINHIUEJBDLTCUMMUWICIUVCZNIQIUEWVAHLANQIAONMEYJWPDAFXVNOSOFDOCESSLGZPTJINBUAFWWWMPTYALZIGVD
DCZGKILMBFXIQQFEKJBIUDEMIFCANVGNYZAYSQFMNNQFEPZFUUVGTBKSMDXITBLANQIAOQUKTPNYPOWSQQYWWMJHSDYVFDJYXBAF
VGYXAMDRRZWVIHNQPZZWRNWBTROOJOLNUGXBILZKQEGIQSYGKZGODPWBJSCMRRWSSQURUFIAFQGEZLGZNOEQMNQEYUKPEQPPVAMO
SYSFUAJFKIPUJVQSZRWQCJYAUMLDDNOKODDXIEQIFLANQIAOZFUNKUBVDBLMJOAUTVCZVLKJRQIORQPGAVCEYVNYUZHXILHERYEC
GJEKWEKIJNIWUXZNVIWIAANHIOSOLATSQFSSCTAKESUTSPPYFHEHLVLIBJZEEBCOWMNHFTZMAPKFUPNFLTFFJQRVJHAKDVMGGUIX
KAKXXNKSOAIQNALLWKWGVACYWBQEVTFSEUCYRORQTHWFUJFLQHONWZEKPLSNPRPBOMOFFCPMKXFZBKIERBKDYFKYUEYVYRPMOAQI
WNICDLQKZXGTKDLIEFBGELGJOAIQNALXZLGGDQIBVEULDPBWUJNTYOKFBPGMAWRRUJPPIGYCNYURNOSQRIRBAZAGWWDUHAAZQWPT
KFXZQXRMKSBUXWOUVVHSJWTLKZELGXMMAIDSJIWGCJPCBWZIEKMNUPUAFHTUMOZKJWVTIAQNOHELEMWGKJHKPNJVSRVHAUFXBUOU
XOWCZJYQLXJRUOOYSKDLDXKWTTJBYBTLKSWRUYPOYTPBGUJXBMRWNELBWADCSZDAEEFGPVRHNNLBFDDXNPDXLKQUSJAZDEUDBMBD
QIKYEKMVUHGGWZDKXFVQQNECZOAWCFUBHQMEPEPKEFSDBAYJQOSGAIHRBRAUKLQRANKMTTIOJDDXAEWTQHIYSGRRMEFTNNWCLZSI
ZFUQAQCSFNVUQMKUQWBWFQIEQVVXPOSVIDTUOBLLTGHQKEMSUWWHWRISLGRDPPQPZBANSGDWXKNYTKMWECPMPDYSCJZXPUKPWGYI
CNGVLBSCBHRLJARWSRENGHYYQDKRATERCPEAOPAJZUMOYIDHVPDMQPKKHCBAMRBGEIEXXJALMCXKPUGXYVINRORFYURXAMOJCBZQ
YJHHAWESCLMDIHVYMLAJZQSYTDEURWYPOLJCAKIKSATGVIALBLWPPKDEGSPMRLDBQNVPPCLQXKUQLQJERMYFGAETUATEBQZUMGUN
NBWUBVXYDFPLPJYLIDFVTVKKGFWMXVINLJUDUPABTSBJAJENZSXIMUJQWPEZTAVDMBBHFYTJKYFXIXQTBTTQIKQXQDPWYNMXRQDJ
OGWLZQUBJJHAQNPVRGHGPNMMJPIDGANYEEDWYPOLKLNEPYSRTQYCJLSWFRJRRGGSNSDHIXYYSNAKKBWQDDGYYMOGPUXQEUSAPSOU
CLLSELRVFZUFYVTJQKCQHNICMERWQFQNPVRPIIYKHZWJYJAFCLNSZXUHSPOZWQUMJHLKKYJENVZOCSWCTPYWIZONUUCLSUROGAYS
AZGNIMXPLPCEPULRRBHHQOBELHJZPUQAMWUASVKDXVEWAOFMAYSJFXHCNEUXUQWUESFBRUFZQLKKWHCHKOPLECCBYSLECAEZIMMI
TUUEOCEBAUKWLTSYJJPLZTIARAOZXKYYWIOXBBTZZCSAULKNEJWVQXIKUWBIWVHGNTHVBAWAVPGLHSDJDLPVHHHUNVSFKXARXLVQ
EMVDFSLANQIAOPTLFLFRKGNUZCTXWCAXHECTZFHWUFENRGQICHTYLSHZWIEGLNVDJZOMTKAAUWOHVOVOCTUKOSINSAYIAEUYORNA
VGPRMLCAQZIPRFQOZMEFTQZYVOTVFNVOIQSJCIPPQXQKJIXICUIGMHAJJMSXENCBQFIJHNZXIQMWACKDKQSEWWKMLOAUPFHAZGRY
SQWQMRSQBGGKYKGWEZYRIHWGNXRPOUMFSFGTYDLUDWPWAVQORTMQUXWKUQVNMDPWQFIZPOIHCJATODRQGZDMQXZVNXXVEJNGWZOM
PVBGZSQPCELDIWDHOQWAUHILGLPYRIICTLFSOYKQZYZOCIZPTECSWOODGGBDTSGIMYGMVPJPRPEVWOOKYFWRGXHWUCRQNYJEMSYL
XWOFXFVDXPTHYTCEGMODCILAHYBREZVVHOUPZKCNHUEVPMKHUBNRPFMWXVQACVZCALZLYMZSBLCEASPMIEFOTGKMPGWYQADSNDPR
QPHAVLZDZLKIEISFLLVWXAVBZLZIJRHGROUVGXRDLUJAXNHBBZYNCVERJGSKLWZEKGJBCWMSMLYIHZFFMIOGVIMZQBSRHQWAADYN
MNXEGTDXCDKIUDOISQXEUJWETPELKBCYFSDNJQWNNBPYMWBUPQBAAINMYZOYCEGNLFNNHZFEMSQVXJJGWBCRAVKZFWFBKMBRVBFD
HKACSZIUWUXLWKFPKOCUQJEPQDZCMUJFLVCLIOQQRVKSWFIAKNHMRLNJTKGVNTGLCVPVMBLJANOBCXUGVWBJYSIXZQVAVFWILWFB
QWNLTPMCYHRSKVHXLONRANWKWXUTHYQLIOFKGDBMSWDRCYRKVSAGGRJMWQYQFLMUIGGCLAUQAACTYLPZEOJBHMWRKHCRXGTGRMUP
CPQKJRBLYDNPUGHCRBVYBAIRVCAWLBWVWCMKNBIRKJOUGYQEBQRHDSTWXDIWGRVMLIJFBWHLHCDAAVUDLZSCGQNOUXVUIVIZZZMD
NMHGYPFUUDWKQGTAKKGCDFJFYJFNRZVXDPGZEAMWQVQZODKTXHIYFVKJSSAWVHYCUCZMLLBPXTILDYJQEMWDRUFKISOUVPUDTYPB
FDAQUBXHUJYTAYNWVIJNUSQDTQDEMUAPWXRYUWONTBDZCHZOUEGPMWEZTQWWSHAYOBWVTDIMZYNVNZKUHOFCQKPHJXWNRCGUJEKO
WSDAUGUTVWCVHEMOIRJJGTANUWTSAIXXEVZTBDHPGSRHHVWCDZVZYRJTLONIJVXEATHQXOUKBIGZONFRSZIOGWNTYAJYLQCGEOWY
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/字符串编码/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字符串编码
#### 问题描述
小明发明了一种给由全大写字母组成的字符串编码的方法。
对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。
这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。
现在给定一个转换后的数字序列，小明想还原出原本的字符串。
当然这样的还原有可能存在多个符合条件的字符串。
小明希望找出其中字典序最大的字符串。
#### 输入格式
一个数字序列。
#### 输出格式
一个只包含大写字母的字符串，代表答案
#### 样例输入
```
123242526
```
#### 样例输出
```
LCXYZ
```
#### 数据范围
```
对于 20% 的评测用例，输入的长度不超过 20。
对于所有评测用例，输入的长度不超过 200000。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/完全二叉树的权值/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 完全二叉树的权值
#### 问题描述
给定一棵包含 N 个节点的完全二叉树，树上每个节点都有一个权值，按从上到下、从左到右的顺序依次是 A 1 , A 2 , ··· A N ，如下图所示：
![](https://img-blog.csdnimg.cn/20210402205939738.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc5NjMxNg==,size_16,color_FFFFFF,t_70)
现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点
权值之和最大？如果有多个深度的权值和同为最大，请你输出其中最小的深度。
**注：根的深度是 1。**
#### 输入格式
第一行包含一个整数 N。
第二行包含 N 个整数 A 1 , A 2 , ··· A N 。
#### 输出格式
输出一个整数代表答案。
#### 样例输入
```
7
1 6 5 4 3 2 1
```
#### 样例输出
```
2
```
#### 评测用例规模与约定
对于所有评测用例，1 ≤ N ≤ 100000，−100000 ≤ A i ≤ 100000。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/完美平方数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 完美平方数
如果整个整数 X 本身是完全平方数，同时它的每一位数字也都是完全平方数，我们就称 X 是完美平方数。
前几个完美平方数是 0、1、4、9、49、100、144……
即第 1 个完美平方数是 0，第 2 个是 1，第 3 个是 4，……
请你计算第 2020 个完美平方数是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/密码发生器/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 密码发生器
在对银行账户等重要权限设置密码的时候，我们常常遇到这样的烦恼：如果为了好记用生日吧，容易被破解不安全；如果设置不好记的密码，又担心自己也会忘记；如果写在纸上，担心纸张被别人发现或弄丢了...
这个程序的任务就是把一串拼音字母转换为6位数字（密码）。我们可以使用任何好记的拼音串(比如名字，喜明，就写：wangximing)作为输入，程序输出6位数字。
变换的过程如下：
第一步. 把字符串6个一组折叠起来，比如wangximing则变为：
wangxi
ming
第二步. 把所有垂直在同一个位置的字符的ascii码值相加，得出6个数字，如上面的例子，则得出：
228 202 220 206 120 105
第三步. 再把每个数字“缩位”处理：就是把每个位的数字相加，得出的数字如果不是一位数字，就再缩位，到变成一位数字为止。例如: 228 => 2+2+8=12 => 1+2=3
上面的数字缩位后变为：344836, 这就是程序最终的输出结果！
要求程序从标准输入接收数据，在标准输出上输出结果。
#### 输入格式为：
第一行是一个整数n（<100），表示下边有多少输入行，接下来是n行字符串，就是等待变换的符串。
#### 输出格式为：
n行变换后的6位密码。
#### 输入：
```
5
zhangfeng
wangximing
jiujingfazi
woaibeijingtiananmen
haohaoxuexi
```
#### 输出：
```
772243
344836
297332
716652
875843
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/密码脱落/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 密码脱落
X星球的考古学家发现了一批古代留下来的密码。
这些密码是由A、B、C、D 四种植物的种子串成的序列。
仔细分析发现，这些密码串当初应该是前后对称的（也就是我们说的镜像串）。
由于年代久远，其中许多种子脱落了，因而可能会失去镜像的特征。
你的任务是：
给定一个现在看到的密码串，计算一下从当初的状态，它要至少脱落多少个种子，才可能会变成现在的样子。
输入一行，表示现在看到的密码串（长度不大于1000）
要求输出一个正整数，表示至少脱落了多少个种子。
例如，输入：
```
ABCBA
```
则程序应该输出：
```
0
```
再例如，输入：
```
ABDCDCBABC
```
则程序应该输出：
```
3
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/寒假作业/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 寒假作业
现在小学的数学题目也不是那么好玩的。
看看这个寒假作业：
```
□ + □ = □
□ - □ = □
□ × □ = □
□ ÷ □ = □
```
每个方块代表1~13中的某一个数字，但不能重复。比如：
```
6 + 7 = 13
9 - 8 = 1
3 * 4 = 12
10 / 2 = 5
```
以及：
```
7 + 6 = 13
9 - 8 = 1
3 * 4 = 12
10 / 2 = 5
```
就算两种解法。（加法，乘法交换律后算不同的方案）
你一共找到了多少种方案？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/寻找2020/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 寻找2020
小蓝有一个数字矩阵，里面只包含数字 0 和 2。小蓝很喜欢 2020，他想找到这个数字矩阵中有多少个 2020 。
小蓝只关注三种构成 2020 的方式：
* 同一行里面连续四个字符从左到右构成 2020。
* 同一列里面连续四个字符从上到下构成 2020。
* 在一条从左上到右下的斜线上连续四个字符，从左上到右下构成 2020。
例如，对于下面的矩阵：
```
220000
000000
002202
000000
000022
002020
```
一共有 5 个 2020。其中 1 个是在同一行里的，1 个是在同一列里的，3 个是斜线上的。
小蓝的矩阵比上面的矩阵要大，由于太大了，他只好将这个矩阵放在了一个文件里面，在试题目录下有一个文件 2020.txt，里面给出了小蓝的矩阵。
请帮助小蓝确定在他的矩阵中有多少个 2020。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/小朋友崇拜圈/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 小朋友崇拜圈
#### 问题描述：
班里 N个小朋友，每个人都有自己最崇拜的一个小朋友（也可以是自己）。在一个游戏中，需要小朋友坐一个圈，每个小朋友都有自己最崇拜的小朋友在他的右手边。求满足条件的圈最大多少人？小朋友编号为1，2，3....N
#### 输入描述
输入第一行，一个整数N(3 < N < 100000)
接下来一行 N个整数，由空格分开。
#### 输出描述
要求输出一个整数，表示满足条件的最大圈的人数。
### 输入输出样例
#### 输入
```
9
3 4 2 5 3 8 4 6 9
```
#### 输出
```
4
```
#### 样例解释
如下图所示，崇拜关系用箭头表示，红色表示不在圈中。
显然，最大圈是[2 4 5 3] 构成的圈。
![](https://img-blog.csdnimg.cn/20190317193536482.png)
#### 输入：
```
30
22 28 16 6 27 21 30 1 29 10 9 14 24 11 7 2 8 5 26 4 12 3 25 18 20 19 23 17 13 15
```
#### 输出：
```
16
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/小朋友排队/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 小朋友排队
#### 题目描述
n 个小朋友站成一排。
现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。
每个小朋友都有一个不高兴的程度。
开始的时候，所有小朋友的不高兴程度都是 0。
如果某个小朋友第一次被要求交换，则他的不高兴程度增加 1，如果第二次要求他交换，则他的不高兴程度增加 2（即不高兴程度为 3），依次类推。当要求某个小朋友第 k 次交换时，他的不高兴程度增加 k。
请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。
如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。
#### 输入格式
输入的第一行包含一个整数 n，表示小朋友的个数。
第二行包含 n 个整数 H1,H2,…,Hn，分别表示每个小朋友的身高。
#### 输出格式
输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。
#### 数据范围
```
1≤n≤100000,
0≤Hi≤1000000
```
#### 输入样例：
```
3
3 2 1
```
#### 输出样例：
```
9
```
#### 样例解释
首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/带分数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 带分数
#### 问题描述
100 可以表示为带分数的形式：100 = 3 + 69258 / 714。
还可以表示为：100 = 82 + 3546 / 197。
注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。
类似这样的带分数，100 有 11 种表示法。
#### 输入格式
从标准输入读入一个正整数N (N<1000*1000)
#### 输出格式
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！
#### 样例输入1
```
100
```
#### 样例输出1
```
11
```
#### 样例输入2
```
105
```
#### 样例输出2
```
6
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/平方和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 平方和
小明对数位中含有 2、0、1、9 的数字很感兴趣，在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574，平方和是 14362。注意，平方和是指将每个数分别平方后求和。
请问，在 1 到 2019 中，所有这样的数的平方和是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/平面分割/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 平面分割
20个圆和20条直线最多能把平面分成多少个部分?
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/平面切分/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 平面切分
#### 问题描述
平面上有 N条直线，其中第 i条直线是$ y = A_i*x + B_i$。
请计算这些直线将平面分成了几个部分。
#### 输入格式
第一行包含一个整数N。
以下N行，每行包含两个整数 $A_i, B_i$。
#### 输出格式
一个整数代表答案。
#### 样例输入
```
3
1 1
2 2
3 3
```
#### 样例输出
```
6
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/年号字符/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 年号字符
小明用字母 A 对应数字 1，B 对应 2，以此类推，用 Z 对应 26。对于 27 以上的数字，小明用两位或长位的字符串来对应，例如 AA 对应 27，AB 对 应 28，AZ 对应 52，LQ 对应 329。
请问 2019 对应的字符串是什么？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/幸运数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 幸运数
#### 问题描述
幸运数是波兰数学家乌拉姆命名的。它采用与生成素数类似的“筛法”生成。
首先从1开始写出自然数1,2,3,4,5,6,…
1 就是第一个幸运数。
我们从2这个数开始。把所有序号能被2整除的项删除，变为：
1 _ 3 _ 5 _ 7 _ 9 …
把它们缩紧，重新记序，为：
1 3 5 7 9 … 。
这时，3为第2个幸运数，然后把所有能被3整除的序号位置的数删去。注意，是序号位置，不是那个数本身能否被3整除!! 删除的应该是5，11, 17, …
此时7为第3个幸运数，然后再删去序号位置能被7整除的(19,39,…)
最后剩下的序列类似：
```
1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, …
```
#### 输入格式
输入两个正整数m n, 用空格分开 (m < n < 1000*1000)
#### 输出格式
程序输出 位于m和n之间的幸运数的个数（不包含m和n）。
#### 样例输入1
```
1 20
```
#### 样例输出1
```
5
```
#### 样例输入2
```
30 69
```
#### 样例输出2
```
8
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/循环节长度/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 循环节长度
两个整数做除法，有时会产生循环小数，其循环部分称为：循环节。
比如，11/13=6=>0.846153846153….. 其循环节为[846153] 共有6位。
下面的方法，可以求出循环节的长度。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/微生物增殖/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 微生物增殖
假设有两种微生物 X 和 Y
X出生后每隔3分钟分裂一次（数目加倍），Y出生后每隔2分钟分裂一次（数目加倍）。
一个新出生的X，半分钟之后吃掉1个Y，并且，从此开始，每隔1分钟吃1个Y。
现在已知有新出生的 X=10, Y=89，求60分钟后Y的数目。
如果X=10，Y=90呢？
本题的要求就是写出这两种初始条件下，60分钟后Y的数目。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/快速排序/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 快速排序
#### 问题描述
用递归来实现快速排序（quick sort）算法。快速排序算法的基本思路是：假设要对一个数组a进行排序，且a[0] = x。首先对数组中的元素进行调整，使x放在正确的位置上。同时，所有比x小的数都位于它的左边，所有比x大的数都位于它的右边。然后对于左、右两段区域，递归地调用快速排序算法来进行排序。
#### 输入格式：
输入只有一行，包括若干个整数（不超过10个），以0结尾。
#### 输出格式：
输出只有一行，即排序以后的结果（不包括末尾的0）。
### 输入输出样例
#### 样例输入
```
5 2 6 1 7 3 4 0
```
#### 样例输出
```
1 2 3 4 5 6 7
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/成绩分析/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 成绩分析
#### 问题描述
小蓝给学生们组织了一场考试，卷面总分为 分，每个学生的得分都是一个 到 的整数。
请计算这次考试的最高分、最低分和平均分。
#### 输入格式
输入的第一行包含一个整数 ，表示考试人数。
接下来 行，每行包含一个 至 的整数，表示一个学生的得分。
#### 输出格式
输出三行。
第一行包含一个整数，表示最高分。
第二行包含一个整数，表示最低分。
第三行包含一个实数，四舍五入保留正好两位小数，表示平均分。
#### 样例输入
```
80
92
56
74
88
99
10
```
#### 样例输出
```
99
10
71.29
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/成绩统计/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 成绩统计
#### 问题描述
编写一个程序，建立了一条单向链表，每个结点包含姓名、学号、英语成绩、数学成绩和C++成绩，并通过链表操作平均最高的学生和平均分最低的学生并且输出。
#### 输入格式
输入n+1行，第一行输入一个正整数n，表示学生数量；接下来的n行每行输入5个数据，分别表示姓名、学号、英语成绩、数学成绩和C++成绩。注意成绩有可能会有小数。
#### 输出格式
输出两行，第一行输出平均成绩最高的学生姓名。第二行输出平均成绩最低的学生姓名。
#### 样例输入
```
2
yx1 1 45 67 87
yx2 2 88 90 99
```
#### 样例输出
```
yx2
yx1
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/手链样式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 手链样式
小明有3颗红珊瑚，4颗白珊瑚，5颗黄玛瑙。
他想用它们串成一圈作为手链，送给女朋友。
现在小明想知道：如果考虑手链可以随意转动或翻转，一共可以有多少不同的组合样式呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/扑克序列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 扑克序列
A A 2 2 3 3 4 4， 一共4对扑克牌。请你把它们排成一行。
要求：两个A中间有1张牌，两个2之间有2张牌，两个3之间有3张牌，两个4之间有4张牌。
请填写出所有符合要求的排列中，字典序最小的那个。
例如：22AA3344 比 A2A23344 字典序小。当然，它们都不是满足要求的答案。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/打印图形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 打印图形
小明在X星球的城堡中发现了如下图形和文字：
```
rank=3
*
* *
* *
* * * *
rank=5
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
ran=6
*
* *
* *
* * * *
* *
* * * *
* * * *
* * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
* *
* * * *
* * * *
* * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
* * * *
* * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
```
小明开动脑筋，编写了如下的程序，实现该图形的打印。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/打印菱形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 打印菱形
给出菱形的边长，在控制台上打印出一个菱形来。
为了便于比对空格，我们把空格用句点代替。
当边长为8时，菱形为：
```
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/承压计算/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 承压计算
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。
```
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X
```
其中的数字代表金属块的重量（计量单位较大）。
最下一层的X代表30台极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的计量单位很小，所以显示的数字很大。
工作人员发现，其中读数最小的电子秤的示数为：```2086458231```
请你推算出：读数最大的电子秤的示数为多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/抽签/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 抽签
X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
....
那么最终派往W星的观察团会有多少种国别的不同组合呢？
#### 输入格式
第一行N,以下N行代表N个国家最多可派出人数Ai。
#### 输出格式
最多多少种派法ANS，ANS为一个整数。
#### 输出规模
```
1<N<10000
1<AI<10000
```
#### 示例输入
```
6
4
2
2
1
1
3
```
示例输出
```
101
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/振兴中华/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 振兴中华
小明参加了学校的趣味运动会，其中的一个项目是：跳格子。
地上画着一些格子，每个格子里写一个字，如下所示：
```
从我做起振
我做起振兴
做起振兴中
起振兴中华
```
![](https://img-blog.csdn.net/20180327194316347)
比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位置。一直要跳到“华”字结束。
要求跳过的路线刚好构成“从我做起振兴中华”这句话。
请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/排它平方数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 排它平方数
203879 * 203879 = 41566646641
这有什么神奇呢？仔细观察，203879 是个6位数，并且它的每个数位上的数字都是不同的，并且它平方后的所有数位上都不出现组成它自身的数字。
具有这样特点的6位数还有一个，请你找出它！
再归纳一下筛选要求：
1. 6位正整数
2. 每个数位上的数字不同
3. 其平方数的每个数位不含原数字的任何组成数位
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/排序/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 排序
#### 问题描述
编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。
输入格式：输入只有一行，即三个整数，中间用空格隔开。
输出格式：输出只有一行，即排序后的结果。
### 输入输出样例
#### 样例输入
```
9 2 30
```
#### 样例输出
```
30 9 2
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/搭积木/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 搭积木
小明最近喜欢搭数字积木，
一共有10块积木，每个积木上有一个数字，0~9。
搭积木规则：
每个积木放到其它两个积木的上面，并且一定比下面的两个积木数字小。
最后搭成4层的金字塔形，必须用完所有的积木。
下面是两种合格的搭法：
```
0
1 2
3 4 5
6 7 8 9
0
3 1
7 5 2
9 8 6 4
```
请你计算这样的搭法一共有多少种？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/放棋子/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 放棋子
今有6×6的棋盘，其中某些格子已预放了棋子。现在要再放上去一些，使得每行每列都正好有3颗棋子。我们希望推算出所有可能的放法，下面的代码就实现了这个功能。初始数组中，“1”表示放有棋子，“0”表示空白。
![](https://img-blog.csdn.net/20170302185510449)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/数列求值/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 数列求值
给定数列1, 1, 1, 3, 5, 9, 17, …，从第4 项开始，每项都是前3 项的和。求第20190324 项的最后4 位数字。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/数字三角形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 数字三角形
#### 题目描述
![](https://img-blog.csdnimg.cn/20210330204547371.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjIzOTM3MA==,size_16,color_FFFFFF,t_70)
上图给出了一个数字三角形。
从三角形的顶部到底部有很多条不同的路径。
对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。
路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右边的那个数。
此外，向左下走的次数与向右下走的次数相差不能超过 1。
#### 输入格式
输入的第一行包含一个整数 N，表示三角形的行数。
下面的 N 行给出数字三角形。
数字三角形上的数都是 0 至 100 之间的整数。
#### 输出格式
输出一个整数，表示答案。
#### 输入样例
```
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
```
#### #### 输出样例
```
27
```
数据范围
```
1 ≤ N ≤ 100
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/数的分解/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 数的分解
把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包含数字 2 和 4，一共有多少种不同的分解方法？
注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/整数拼接/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 整数拼接
#### 问题描述
给定义个长度为 n 的数组 $A_1, A_2 , ··· , A_n$。
你可以从中选出两个数 $A_i 和 A_j$ (i 不等于 j)，然后将 $A_i 和 A_j$ 一前一后拼成一个新的整数。
例如 12 和 345 可以拼成 12345 或 34512。
注意交换 $A_i$ 和 $A_j$ 的顺序总是被视为 2 种拼法，即便是 $A_i$ = $A_j$ 时。
请你计算有多少种拼法满足拼出的整数是 K 的倍数。
#### 输入格式
第一行包含 2 个整数 n 和 K。
第二行包含 n 个整数 $A_1, A_2 , ··· , A_n$。
#### 输出格式
一个整数代表答案。
#### 样例输入
```
4 2
1 2 3 4
```
#### 样例输出
```
6
```
#### 数据范围
对于 30% 的评测用例，1 ≤ n ≤ 1000, 1 ≤ K ≤ 20, 1 ≤ $A_i$ ≤ $10^4$
对于所有评测用例，1 ≤ n ≤ $10^5$，1 ≤ K ≤ $10^5$ ，1 ≤ $A_i$ ≤ $10^9$
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/整除序列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 整除序列
有一个序列，序列的第一个数是n，后面的每个数是前一个数整除2，请输出这个序列中值为正数的项。
#### 输入格式
输入一行包含一个整数n。
#### 输出格式
输出一行，包含多个整数，相邻的整数之间用一个空格分隔，表示答案。
#### 样例输入
```
20
```
#### 样例输出
```
20 10 5 2 1
```
#### 评测用例规模与约定
```
对于80% 的评测用例，1 < n <= 10^9。
对于所有评测用例，1 < n <=10^18。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/斐波那契/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 斐波那契
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
#### 输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
#### 样例输入
```
10
```
#### 样例输出
```
55
```
#### 样例输入
```
22
```
#### 样例输出
```
7704
```
#### 数据规模与约定
```
1 <= n <= 1,000,000。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/斐波那契数列最大公约数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 斐波那契数列最大公约数
#### 问题描述
斐波那契数列满足 F1 = F2 = 1，从 F3 开始有 Fn = Fn−1 + Fn−2。请你计算 GCD(F2020, F520)，其中 GCD(A, B) 表示 A 和 B 的最大公约数。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/方块分割/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 方块分割
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/方格分割/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 方格分割
6x6的方格，沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图：
![](https://img-blog.csdn.net/20180321145603391)
![](https://img-blog.csdn.net/20180321145607269)
![](https://img-blog.csdn.net/20180321145611157)
就是可行的分割法。
试计算：
包括这3种分法在内，一共有多少种不同的分割方法。
注意：旋转对称的属于同一种分割法。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/方格填数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 方格填数
如下图
![](https://img-blog.csdnimg.cn/20190313140048205.jpg)
填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）
一共有多少种可能的填数方案？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/方格计数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 方格计数
如图所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
![](https://upload-images.jianshu.io/upload_images/15659652-2abc8a1de9a368d2.png?imageMogr2/auto-orient/strip|imageView2/2/w/394/format/webp)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/方程整数解/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 方程整数解
#### 题目描述
方程: a^2 + b^2 + c^2 = 1000
这个方程有正整数解吗？有：a,b,c=6,8,30 就是一组解。
求出 a^2 + b^2 + c^2 = n(1<=n<=10000)的所有解，解要保证c>=b>=a>=1。
#### 输入
存在多组测试数据，每组测试数据一行包含一个正整数n(1<=n<=10000)
#### 输出
如果无解则输出"No Solution"。
如果存在多解，每组解输出1行，输出格式：a b c，以一个空格分隔
按照a从小到大的顺序输出，如果a相同则按照b从小到大的顺序输出，如果a,b都相同则按照c从小到大的顺序输出。
#### 样例输入
```
4
1000
```
#### 样例输出
```
No Solution
6 8 30
10 18 24
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/方阵转置/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 方阵转置
#### 问题描述
给定一个n×m矩阵相乘，求它的转置。其中1≤n≤20，1≤m≤20，矩阵中的每个元素都在整数类型（4字节）的表示范围内。
#### 输入格式
第一行两个整数n和m；
第二行起，每行m个整数，共n行，表示n×m的矩阵。数据之间都用一个空格分隔。
#### 输出格式
共m行，每行n个整数，数据间用一个空格分隔，表示转置后的矩阵。
#### 样例输入
```
2 4
34 76 -54 7
-4 5 23 9
```
#### 样例输出
```
34 -4
76 5
-54 23
7 9
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/既约分数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 既约分数
如果一个分数的分子和分母的最大公约数是 1，这个分数称为既约分数。
例如，3/4 , 2/5, 1/8 , 1/7 都是既约分数。
请问，有多少个既约分数，分子和分母都是 1 到 2020 之间的整数（包括 1 和 2020）？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/日志统计/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 日志统计
#### 题目描述
小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有 N 行。
其中每一行的格式是：
ts id
表示在 ts 时刻编号 id 的帖子收到一个”赞”。
现在小明想统计有哪些帖子曾经是”热帖”。
如果一个帖子曾在任意一个长度为 D 的时间段内收到不少于 K 个赞，小明就认为这个帖子曾是”热帖”。
具体来说，如果存在某个时刻 T 满足该帖在 [T,T+D) 这段时间内(注意是左闭右开区间)收到不少于 K 个赞，该帖就曾是”热帖”。
给定日志，请你帮助小明统计出所有曾是”热帖”的帖子编号。
#### 输入格式
第一行包含三个整数 N,D,K。
以下 N 行每行一条日志，包含两个整数 ts 和 id。
#### 输出格式
按从小到大的顺序输出热帖 id。
每个 id 占一行。
#### 数据范围
```
1≤K≤N≤10E5,
0≤ts,id≤10E5,
1≤D≤10000
```
#### 输入样例：
```
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
```
#### 输出样例：
```
1
3
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/日期问题/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
#### 输入
一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)
#### 输出
输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。
#### 样例输入
```
02/03/04
```
#### 样例输出
```
2002-03-04
2004-02-03
2004-03-02
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/明码/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 明码
汉字的字形存在于字库中，即便在今天，16点阵的字库也仍然使用广泛。
16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中。
一个字节可以存储8位信息，用32个字节就可以存一个汉字的字形了。
把每个字节转为2进制表示，1表示墨迹，0表示底色。
每行2个字节，一共16行，布局是：
第1字节，第2字节
第3字节，第4字节
…
第31字节, 第32字节
这道题目是给你一段多个汉字组成的信息，每个汉字用32个字节表示，这里给出了字节作为有符号整数的值。
题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形，从中看出题目的要求，并根据要求填写答案。
这段信息是（一共10个汉字）：
```
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16
4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4
4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64
16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128
0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0
2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0
1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0
0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/星期一/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 星期一
整个20世纪（1901年1月1日至2000年12月31日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/星系炸弹/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 星系炸弹
在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。
每个炸弹都可以设定多少天之后爆炸。
比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。
有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/最大公共子串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最大公共子串
最大公共子串长度问题就是：
求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/最大比例/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最大比例
X星球的某个大奖赛设了 M 级奖励。
每个级别的奖金是一个正整数。
并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。
比如：16,24,36,54，其等比值为：3/2。
现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。
#### 输入格式
第一行为数字 N ，表示接下的一行包含 N 个正整数。
第二行 N 个正整数 Xi，用空格分开，每个整数表示调查到的某人的奖金数额。
#### 输出格式
一个形如 A/B 的分数，要求 A、B 互质，表示可能的最大比例系数。
#### 数据范围
$0< N < 100$
$0 < X_i < 10^12$
数据保证一定有解。
#### 输入样例1：
```
3
1250 200 32
```
#### 输出样例1：
```
25/4
```
#### 输入样例2：
```
4
3125 32 32 200
```
#### 输出样例2：
```
5/2
```
#### 输入样例3：
```
3
549755813888 524288 2
```
#### 输出样例3：
```
4/1
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/有理数类/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 有理数类
有理数就是可以表示为两个整数的比值的数字。一般情况下，我们用近似的小数表示。
但有些时候，不允许出现误差，必须用两个整数来表示一个有理数。
这时，我们可以建立一个“有理数类”，下面的代码初步实现了这个目标。
为了简明，它只提供了加法和乘法运算。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/李白打酒/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 李白打酒
话说大诗人李白，一生好饮。幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：
无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。
请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/格子中输出/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 格子中输出
StringInGrid函数会在一个指定大小的格子中打印指定的字符串。 要求字符串在水平、垂直两个方向上都居中。 如果字符串太长，就截断。 如果不能恰好居中，可以稍稍偏左或者偏上一点。
输出：
![](https://img-blog.csdnimg.cn/20200327144609874.png#pic_center)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/梅森素数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 梅森素数
如果一个数字的所有真因子之和等于自身，则称它为“完全数”或“完美数”
例如：6 = 1 + 2 + 3
28 = 1 + 2 + 4 + 7 + 14
早在公元前300多年，欧几里得就给出了判定完全数的定理：
若 2^n - 1 是素数，则 2^(n-1) * (2^n - 1) 是完全数。
其中 ^ 表示“乘方”运算，乘方的优先级比四则运算高，例如：2^3 = 8， 2 * 2^3 = 16, 2^3-1 = 7
但人们很快发现，当n很大时，判定一个大数是否为素数到今天也依然是个难题。
因为法国数学家梅森的猜想，我们习惯上把形如：2^n - 1 的素数称为：梅森素数。
截止2013年2月，一共只找到了48个梅森素数。 新近找到的梅森素数太大，以至于难于用一般的编程思路窥其全貌，所以我们把任务的难度降低一点：
1963年，美国伊利诺伊大学为了纪念他们找到的第23个梅森素数 n=11213，在每个寄出的信封上都印上了“2^11213-1 是素数”的字样。
2^11213 - 1 这个数字已经很大(有3000多位)，请你编程求出这个素数的十进制表示的最后100位。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/次数差/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 次数差
#### 问题描述
x星球有26只球队，分别用 a ~ z 的26个字母代表。他们总是不停地比赛。
在某一赛段，哪个球队获胜了，就记录下代表它的字母，这样就形成一个长长的串。
国王总是询问：获胜次数最多的和获胜次数最少的有多大差距？
（当然，他不关心那些一次也没获胜的，认为他们在怠工罢了）
#### 输入格式
一个串，表示球队获胜情况（保证串的长度<1000）
#### 输出格式
要求输出一个数字，表示出现次数最多的字母比出现次数最少的字母多了多少次。
#### 样例输入1
```
abaabcaa
```
#### 样例输出1
```
4
```
#### 提示
```
a 出现 5 次，最多；c 出现1次，最少。
5 - 1 = 4
```
#### 样例输入2
```
bbccccddaaaacccc
```
#### 样例输出2
```
6
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/正则问题/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 正则问题
#### 问题描述：
考虑一种简单的正则表达式：只由```x()|```组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。
例如```((xx|xxx)x|(x|xx))xx``` 能接受的最长字符串是： ```xxxxxx```，长度是6。
#### 输入格式：
一个由```x()|```组成的正则表达式。输入长度不超过100，保证合法。
#### 输出格式：
这个正则表达式能接受的最长字符串的长度。
#### 样例输入：
```
((xx|xxx)x|(x|xx))xx
```
样例输出：
```
6
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/武功秘籍/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 武功秘籍
小明到X山洞探险，捡到一本有破损的武功秘籍（2000多页！当然是伪造的）。他注意到：书的第10页和第11页在同一张纸上，但第11页和第12页不在同一张纸上。
小明只想练习该书的第81页到第92页的武功，又不想带着整本书。请问他至少要撕下多少张纸带走？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/比酒量/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 比酒量
有一群海盗（不多于20人），在船上比拼酒量。过程如下：打开一瓶酒，所有在场的人平分喝下，有几个人倒下了。再打开一瓶酒平分，又有倒下的，
再次重复......
直到开了第4瓶酒，坐着的已经所剩无几，海盗船长也在其中。当第4瓶酒平分喝下后，大家都倒下了。
等船长醒来，发现海盗船搁浅了。他在航海日志中写到：“......昨天，我正好喝了一瓶.......奉劝大家，开船不喝酒，喝酒别开船......”
请你根据这些信息，推断开始有多少人，每一轮喝下来还剩多少人。
如果有多个可能的答案，请列出所有答案，每个答案占一行。
格式是：人数,人数,...
例如,有一种可能是：```20,5,4,2,0```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/油漆面积/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 油漆面积
#### 问题描述
X星球的一批考古机器人正在一片废墟上考古。
该区域的地面坚硬如石、平整如镜。
管理人员为方便，建立了标准的直角坐标系。
每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。
经过各种测量，每个机器人都会报告一个或多个矩形区域，作为优先考古的区域。
矩形的表示格式为(x1,y1,x2,y2)，代表矩形的两个对角点坐标。
为了醒目，总部要求对所有机器人选中的矩形区域涂黄色油漆。
小明并不需要当油漆工，只是他需要计算一下，一共要耗费多少油漆。
其实这也不难，只要算出所有矩形覆盖的区域一共有多大面积就可以了。
注意，各个矩形间可能重叠。
本题的输入为若干矩形，要求输出其覆盖的总面积。
　　
#### 输入格式
第一行，一个整数n，表示有多少个矩形(1<=n<10000)
接下来的n行，每行有4个整数x1 y1 x2 y2，空格分开，表示矩形的两个对角顶点坐标。
(0<= x1,y1,x2,y2 <=10000)
#### 输出格式
一行一个整数，表示矩形覆盖的总面积面积。
#### 样例输入
```
3
1 5 10 10
3 1 20 20
2 7 15 17
```
#### 样例输出
```
340
```
#### 样例输入
```
3
5 2 10 6
2 7 12 10
8 1 15 15
```
#### 样例输出
```
128
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/波动数列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 波动数列
#### 问题描述
观察这个数列：
1 3 0 2 -1 1 -2 ...
这个数列中后一项总是比前一项增加2或者减少3。
栋栋对这种数列很好奇，他想知道长度为 ```n``` 和为 ```s``` 而且后一项总是比前一项增加a或者减少b的整数数列可能有多少种呢？
#### 输入格式
　　输入的第一行包含四个整数``` n s a b```，含义如前面说述。
#### 输出格式
　　输出一行，包含一个整数，表示满足条件的方案数。由于这个数很大，请输出方案数除以100000007的余数。
#### 样例输入
```4 10 2 3```
#### 样例输出
```2```
#### 样例说明
这两个数列分别是```2 4 1 3```和```7 4 1 -2```。
#### 数据规模和约定
对于10%的数据，1<=n<=5，0<=s<=5，1<=a,b<=5；
对于30%的数据，1<=n<=30，0<=s<=30，1<=a,b<=30；
对于50%的数据，1<=n<=50，0<=s<=50，1<=a,b<=50；
对于70%的数据，1<=n<=100，0<=s<=500，1<=a, b<=50；
对于100%的数据，1<=n<=1000，-1,000,000,000<=s<=1,000,000,000，1<=a, b<=1,000,000。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/测试次数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 测试次数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/消除尾一/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 消除尾一
下面的代码把一个整数的二进制表示的最右边的连续的1全部变成0
如果最后一位是0，则原数字保持不变。
#### 输入：
```
00000000000000000000000001100111
```
#### 输出：
```
00000000000000000000000001100000
```
#### 输入：
```
00000000000000000000000000001100
```
#### 输出：
```
00000000000000000000000000001100
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/灵能传输/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 灵能传输
#### 题目背景
在游戏《星际争霸 II》中，高阶圣堂武士作为星灵的重要 AOE 单位，在游戏的中后期发挥着重要的作用，其技能”灵能风暴“可以消耗大量的灵能对一片区域内的敌军造成毁灭性的伤害。经常用于对抗人类的生化部队和虫族的
刺蛇飞龙等低血量单位。
#### 问题描述
你控制着 n 名高阶圣堂武士，方便起见标为 1,2,··· ,n。每名高阶圣堂武士需要一定的灵能来战斗，每个人有一个灵能值$a_i$表示其拥有的灵能的多少（$a_i$非负表示这名高阶圣堂武士比在最佳状态下多余了$a_i$点灵能，$a_i$为负则表示这名高阶圣堂武士还需要$-a_i$点灵能才能到达最佳战斗状态） 。现在系统赋予了你的高阶圣堂武士一个能力，传递灵能，每次你可以选择一个$ i ∈ [2,n − 1]$，若$a_i ≥ 0 $则其两旁的高阶圣堂武士，也就是$ i − 1、i + 1 $这两名高阶圣堂武士会从i 这名高阶圣堂武士这里各抽取$ a_i $点灵能；若$ a_i < 0 $则其两旁的高阶圣堂武士，也就是$ i−1,i+1 $这两名高阶圣堂武士会给 i 这名高阶圣堂武士$ −a_i $点灵能。形式化来讲就是$ a_{i-1} + = a_i ,a_{i+1} + = a_i ,a_i − = 2a_i $。
灵能是非常高效的作战工具，同时也非常危险且不稳定，一位高阶圣堂武士拥有的灵能过多或者过少都不好，定义一组高阶圣堂武士的不稳定度为$max^n_{i=1} |a_i|$，请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武士的不稳定度最小。
#### 输入格式
本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。
接下来依次输入每一组询问。
每组询问的第一行包含一个正整数 n，表示高阶圣堂武士的数量。
接下来一行包含 n 个数 $a_1 ,a_2 ,··· ,a_n $。
#### 输出格式
输出 T 行。每行一个整数依次表示每组询问的答案。
#### 样例输入
```
3
3
5 -2 3
4
0 0 0 0
3
1 2 3
```
#### 样例输出
```
3
0
3
```
#### 样例说明
```
对于第一组询问：
对 2 号高阶圣堂武士进行传输操作后 a 1 = 3，a 2 = 2，a 3 = 1。答案为 3。
对于第二组询问：
这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。
```
#### 样例输入
```
3
4
-1 -2 -3 7
4
2 3 4 -8
5
-1 -1 6 -1 -1
```
#### 样例输出
```
5
7
4
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/灾后重建/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 灾后重建
#### 问题描述：
Pear市一共有N（<=50000）个居民点，居民点之间有M（<=200000）条双向道路相连。这些居民点两两之间都可以通过双向道路到达。这种情况一直持续到最近，一次严重的地震毁坏了全部M条道路。
震后，Pear打算修复其中一些道路，修理第i条道路需要Pi的时间。不过，Pear并不打算让全部的点连通，而是选择一些标号特殊的点让他们连通。
Pear有Q（<=50000）次询问，每次询问，他会选择所有编号在[l,r]之间，并且 编号 mod K = C 的点，修理一些路使得它们连通。由于所有道路的修理可以同时开工，所以完成修理的时间取决于花费时间最长的一条路，即涉及到的道路中Pi的最大值。
你能帮助Pear计算出每次询问时需要花费的最少时间么？这里询问是独立的，也就是上一个询问里的修理计划并没有付诸行动。
#### 输入格式
第一行三个正整数N、M、Q，含义如题面所述。
接下来M行，每行三个正整数Xi、Yi、Pi，表示一条连接Xi和Yi的双向道路，修复需要Pi的时间。可能有自环，可能有重边。1<=Pi<=1000000。
接下来Q行，每行四个正整数Li、Ri、Ki、Ci，表示这次询问的点是[Li,Ri]区间中所有编号Mod Ki=Ci的点。保证参与询问的点至少有两个。
#### 输出格式
输出Q行，每行一个正整数表示对应询问的答案。
#### 样例输入
```
7 10 4
1 3 10
2 6 9
4 1 5
3 7 4
3 6 9
1 5 8
2 7 4
3 2 10
1 7 6
7 6 9
1 7 1 0
1 7 3 1
2 5 1 0
3 7 2 1
```
#### 样例输出
```
9
6
8
8
```
#### 数据范围
对于20%的数据，N,M,Q<=30
对于40%的数据，N,M,Q<=2000
对于100%的数据，N<=50000,M<=2*10^5,Q<=50000. Pi<=10^6. Li,Ri,Ki均在[1,N]范围内，Ci在[0,对应询问的Ki)范围内。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/煤球数目/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/熊怪吃核桃/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 熊怪吃核桃
森林里有一只熊怪，很爱吃核桃。不过它有个习惯，每次都把找到的核桃分成相等的两份，吃掉一份，留一份。
如果不能等分，熊怪就会扔掉一个核桃再分。第二天再继续这个过程，直到最后剩一个核桃了，直接丢掉。
有一天，熊怪发现了1543个核桃，请问，它在吃这些核桃的过程中，一共要丢掉多少个核桃？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/牌型种数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 牌型种数
小明被劫持到X赌城，被迫与其他3人玩牌。
一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：
如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/特别数的和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 特别数的和
#### 题目描述
小明对数位中含有 2、0、1、9 的数字很感兴趣（不包括前导 0），在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
请问，在 1 到 n 中，所有这样的数的和是多少？
#### 输入格式
共一行，包含一个整数 n。
#### 输出格式
共一行，包含一个整数，表示满足条件的数的和。
#### 数据范围
```
1≤n≤10000
```
#### 输入样例：
```
40
```
#### 输出样例：
```
574
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/猜字母/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 猜字母
把abcd...s共19个字母组成的序列重复拼接106次，得到长度为2014的串。
接下来删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。
得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/猜年龄/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 猜年龄
美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。
一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说：“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。”
请你推算一下，他当时到底有多年轻。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/猴子分香蕉/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 猴子分香蕉
5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。
第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。
第2只猴子醒来，重新把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。
第3只猴子醒来，重新把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。
第4只猴子醒来，重新把香蕉均分成5堆，还剩下4个，就吃掉并把自己的一份藏起来继续睡觉。
第5只猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！
请计算一开始最少有多少个香蕉。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/生命之树/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 生命之树
在X森林里，上帝创建了生命之树。
他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。
上帝要在这棵树内选出一个非空节点集 S，使得对于 S 中的任意两个点 a,b都存在一个点列 {a,v1,v2,…,vk,b} 使得这个点列中的每个点都是 S 里面的元素，且序列中相邻两个点间有一条边相连。
在这个前提下，上帝要使得 S 中的点所对应的整数的和尽量大。
这个最大的和就是上帝给生命之树的评分。
经过 atm 的努力，他已经知道了上帝给每棵树上每个节点上的整数。
但是由于 atm 不擅长计算，他不知道怎样有效的求评分。
他需要你为他写一个程序来计算一棵树的分数。
#### 输入格式
第一行一个整数 n 表示这棵树有 n 个节点。
第二行 n 个整数，依次表示每个节点的评分。
接下来 n−1 行，每行 2 个整数 u,v，表示存在一条 u 到 v 的边。
由于这是一棵树，所以是不存在环的。
树的节点编号从 1 到 n。
#### 输出格式
输出一行一个数，表示上帝给这棵树的分数。
#### 数据范围
```
1≤n≤105,
每个节点的评分的绝对值均不超过 10的6次方。
```
#### 输入样例：
```
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5
```
#### 输出样例：
```
8
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/生日蜡烛/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 生日蜡烛
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。 现在算起来，他一吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/矩阵/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 矩阵
把 1 ∼ 2020 放在 2 × 1010 的矩阵里。
要求同一行中右边的比左边大，同一列中下边的比上边的大。一共有多少种方案？
答案很大，你只需要给出方案数除以 2020 的余数即可。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/矩阵翻硬币/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 矩阵翻硬币
#### 问题描述
小明先把硬币摆成了一个 n 行 m 列的矩阵。
随后，小明对每一个硬币分别进行一次 Q 操作。
对第x行第y列的硬币进行 Q 操作的定义：将所有第 $i*x$ 行，第 $j*y$ 列的硬币进行翻转。
其中i和j为任意使操作可行的正整数，行号和列号都是从1开始。
当小明对所有硬币都进行了一次 Q 操作后，他发现了一个奇迹——所有硬币均为正面朝上。
小明想知道最开始有多少枚硬币是反面朝上的。于是，他向他的好朋友小M寻求帮助。
聪明的小M告诉小明，只需要对所有硬币再进行一次Q操作，即可恢复到最开始的状态。然而小明很懒，不愿意做。于是小明希望你给出他更好的方法。帮他计算出答案。
#### 输入格式
输入数据包含一行，两个正整数 n m，含义见题目描述。
#### 输出格式
输出一个正整数，表示最开始有多少枚硬币是反面朝上的。
#### 样例输入
```
2 3
```
#### 样例输出
```
1
```
#### 数据规模和约定
对于10%的数据，n、m <= 10^3；
对于20%的数据，n、m <= 10^7；
对于40%的数据，n、m <= 10^15；
对于10%的数据，n、m <= 10^1000（10的1000次方）。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/神奇算式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 神奇算式
由4个不同的数字，组成的一个乘法算式，它们的乘积仍然由这4个数字组成。
比如：
```
210 x 6 = 1260
8 x 473 = 3784
27 x 81 = 2187
```
都符合要求。
如果满足乘法交换律的算式算作同一种情况，那么，包含上边已列出的3种情况，一共有多少种满足要求的算式。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/移动距离/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 移动距离
X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3...
当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：
```
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 .....
```
我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）
输入为3个整数w m n，空格分开，都在1到10000范围内
w为排号宽度，m,n为待计算的楼号。
要求输出一个整数，表示m n 两楼间最短移动距离。
例如：
#### 用户输入：
```
6 8 2
```
则，程序应该输出：
```
4
```
再例如：
#### 用户输入：
```
4 7 20
```
则，程序应该输出：
```
5
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/稍小分数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 稍小分数
回到小学
真分数：分子小于分母的分数
既约分数：分子分母互质，也就是说最大公约数是1
x星球数学城的入口验证方式是：
屏幕上显示一个真分数，需要你快速地找到一个比它小的既约分数，要求这个分数越大越好。
同时限定你的这个分数的分母不能超过100。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/立方变自身/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 立方变自身
观察下面的现象,某个数字的立方，按位累加仍然等于自身。
```
1^3 = 1
8^3 = 512 5+1+2=8
17^3 = 4913 4+9+1+3=17
…
```
请你计算包括1,8,17在内，符合这个性质的正整数一共有多少个？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/第39级台阶/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 第39级台阶
小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!
站在台阶前，他突然又想着一个问题：
如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？
请你利用计算机的优势，帮助小明寻找答案。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/第几个幸运数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 第几个幸运数
到x星球旅行的游客都被发给一个整数，作为游客编号。
x星的国王有个怪癖，他只喜欢数字3,5和7。
国王规定，游客的编号如果只含有因子：3,5,7,就可以获得一份奖品。
我们来看前10个幸运数字是：
3 5 7 9 15 21 25 27 35 45
因而第11个幸运数字是：49
小明领到了一个幸运数字 59084709587505，他去领奖的时候，人家要求他准确地说出这是第几个幸运数字，否则领不到奖品。
请你帮小明计算一下，59084709587505是第几个幸运数字。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/第几天/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 第几天
y年m月d日是哪一年的第几天。
比如y年的1月1日是那一年的第一天，那么y年m月d日是哪一年的第几天。
#### 输入
```
y m d
```
#### 输出
输出一个整数
### 样例
#### 输入
```
2000 7 7
```
#### 输出
```
189
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/等差数列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 等差数列
#### 题目描述
数学老师给小明出了一道等差数列求和的题目。
但是粗心的小明忘记了一部分的数列，只记得其中 N 个整数。
现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有几项？
#### 输入格式
输入的第一行包含一个整数 N。
第二行包含 N 个整数 A1,A2,⋅⋅⋅,AN。(注意 A1∼AN 并不一定是按等差数
列中的顺序给出)
#### 输出格式
输出一个整数表示答案。
#### 数据范围
```
2≤N≤100000,
0≤Ai≤109
1
2
```
#### 输入样例：
```
5
2 6 4 10 20
1
2
```
#### 输出样例：
```
10
1
```
#### 样例解释
包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、18、20。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/等差素数列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 等差素数列
#### 题目描述
2,3,5,7,11,13,....是素数序列。
类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。
这是数论领域一项惊人的成果！
有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为10的等差素数列，其公差最小值是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/等腰三角形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 等腰三角形
本题目要求你在控制台输出一个由数字组成的等腰三角形。具体的步骤是：
先用1,2,3，…的自然数拼一个足够长的串
用这个串填充三角形的三条边。从上方顶点开始，逆时针填充。
比如，当三角形高度是8时：
![](https://img-blog.csdnimg.cn/20190203174943179.png)
输入，一个正整数n(3<n<300),表示三角形的高度
输出，用数字填充的等腰三角形。
为了便于测评，我们要求空格一律用"."代替。
### 例如：
#### 输入：
5
#### 程序应该输出：
![](https://img-blog.csdnimg.cn/20190203175048400.png)
### 再例如：
#### 输入：
10
#### 程序应该输出：
![](https://img-blog.csdnimg.cn/20190203175133907.png)
### 再例如：
#### 输入：
15
#### 程序应该输出：
![](https://img-blog.csdnimg.cn/20190203175213126.png)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/糖果/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 糖果
糖果店的老板一共有M种口味的糖果出售。为了方便描述，我们将M种口味编号1~M。
小明希望能品尝到所有口味的糖果。遗憾的是老板并不单独出售糖果，而是K颗一包整包出售。
幸好糖果包装上注明了其中K颗糖果的口味，所以小明可以在买之前就知道每包内的糖果口味。
给定包糖果，请你计算小明最少买几包，就可以品尝到所有口味的糖果。
#### 输入
第一行包含三个整数N、M 和K。
接下来N 行每行K 这整数$T_1,T_2,…,T_K$，代表一包糖果的口味。
1<=N<=100，1<=M<=20，1<=K<=20，1<=$T_i$<=M。
#### 输出
一个整数表示答案。如果小明无法品尝所有口味，输出-1。
#### 样例输入
```
6 5 3
1 1 2
1 2 3
1 1 3
2 3 5
5 4 2
5 1 2
```
#### 样例输出
```
2
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/纪念日/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 纪念日
请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包含多少分钟？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/纸牌三角形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 纸牌三角形
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下面就是一种排法
```
A
9 6
4 8
3 7 5 2
```
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/组合数问题/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 组合数问题
#### 问题描述
给 n, m, k， 求有多少对(i, j)满足 1 ≤ i ≤ n, 0 ≤ j ≤ min(i, m) 且$C_i^j$≡0(mod k)，k 是质数。其中$C_i^j$是组合数，表示从 i 个不同的数中选出 j 个组成一个集合的方案数。
#### 输入格式
第一行两个数 t, k，其中 t 代表该测试点包含 t 组询问，k 的意思与上文中相同。
接下来 t 行每行两个整数 n, m，表示一组询问。
#### 输出格式
输出 t 行，每行一个整数表示对应的答案。由于答案可能很大，请输出答案除以 109 + 7 的余数。
#### 样例输入
```
1 2
3 3
```
#### 样例输出
```
1
```
#### 样例说明
在所有可能的情况中，只有 $C_2^1$ 是 2 的倍数。
#### 样例输入
```
2 5
4 5
6 7
```
#### 样例输出
```
0
7
```
#### 样例输入
```
3 23
23333333 23333333
233333333 233333333
2333333333 2333333333
```
#### 样例输出
```
851883128
959557926
680723120
```
#### 数据规模和约定
```
对于所有评测用例，1 ≤ k ≤ 108, 1 ≤ t ≤ 105, 1 ≤ n, m ≤ 1018，且 k 是质数。评测时将使用 10 个评测用例测试你的程序
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/组队/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 组队
作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。 每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少？
![](https://img-blog.csdnimg.cn/20200328201519748.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxMDMyMA==,size_16,color_FFFFFF,t_70#pic_center)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/绳圈/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 绳圈
今有 100 根绳子，当然会有 200 个绳头。
如果任意取绳头两两配对，把所有绳头都打结连接起来。最后会形成若干个绳圈（不考虑是否套在一起）。
我们的问题是：请计算最后将形成多少个绳圈的概率最大？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/网友年龄/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 网友年龄
某君新认识一网友。 当问及年龄时，他的网友说： “我的年龄是个2位数，我比儿子大27岁, 如果把我的年龄的两位数字交换位置，刚好就是我儿子的年龄”
请你计算：网友的年龄一共有多少种可能情况？
提示：30岁就是其中一种可能哦.
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/网络分析/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 网络分析
#### 问题描述
小明正在做一个网络实验。
他设置了 n 台电脑，称为节点，用于收发和存储数据。初始时，所有节点都是独立的，不存在任何连接。
小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。
小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。
一条信息只存储一次。
给出小明连接和测试的过程，请计算出每个节点存储信息的大小。
#### 输入格式
输入的第一行包含两个整数 n, m，分别表示节点数量和操作数量。节点从1 至 n 编号。
接下来 m 行，每行三个整数，表示一个操作。
如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b时，表示连接了一个自环，对网络没有实质影响。
如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。
#### 输出格式
输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行完上述操作后节点 1 至节点 n 上存储信息的大小。
#### 样例输入
```
4 8
1 1 2
2 1 10
2 3 5
1 4 1
2 2 2
1 1 2
1 2 4
2 2 1
```
#### 样例输出
```
13 13 5 3
```
#### 评测用例规模与约定
```
对于 30% 的评测用例，1 ≤ n ≤ 20，1 ≤ m ≤ 100。
对于 50% 的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 1000。
对于 70% 的评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 10000。
对于所有评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ t ≤ 100。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/翻硬币/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 翻硬币
#### 问题描述
小明正在玩一个“翻硬币”的游戏。
桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
比如，可能情形是：```**oo***oooo```
如果同时翻转左边的两个硬币，则变为：```oooo***oooo```
现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？
我们约定：把翻动相邻的两个硬币叫做一步操作，那么要求：
#### 输入格式
两行等长的字符串，分别表示初始状态和要达到的目标状态。每行的长度<1000
#### 输出格式
一个整数，表示最小操作步数。
#### 样例输入1
```
**********
o****o****
```
#### 样例输出1
```
5
```
#### 样例输入2
```
*o**o***o***
*o***o**o***
```
#### 样例输出2
```
1
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/耐摔指数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 耐摔指数
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
如果已知了测试塔的高度，并且采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
输入数据，一个整数n（3<n<10000）,表示测试塔的高度。
输出一个整数，表示最多测试多少次。
例如：
输入：
```
3
```
程序应该输出：
```
2
```
解释：
```
手机a从2楼扔下去，坏了，就把b手机从1楼扔；否则a手机继续3层扔下
```
再例如：
输入：
```
7
```
程序应该输出：
```
3
```
解释：
```
a手机从4层扔，坏了，则下面有3层，b,c 两部手机2次足可以测出指数；
若是没坏，手机充足，上面5,6,7 三层2次也容易测出。
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/航班时间/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 航班时间
#### 问题背景
小h前往美国参加了蓝桥杯国际赛。小h的女朋友发现小h上午十点出发，上午十二点到达美国，于是感叹到“现在飞机飞得真快，两小时就能到美国了”。
小h对超音速飞行感到十分恐惧。仔细观察后发现飞机的起降时间都是当地时间。由于北京和美国东部有12小时时差，故飞机总共需要14小时的飞行时间。
不久后小h的女朋友去中东交换。小h并不知道中东与北京的时差。但是小h得到了女朋友来回航班的起降时间。小h想知道女朋友的航班飞行时间是多少。
#### 问题描述
对于一个可能跨时区的航班，给定来回程的起降时间。假设飞机来回飞行时间相同，求飞机的飞行时间。
#### 输入格式
从标准输入读入数据。
一个输入包含多组数据。
输入第一行为一个正整数T，表示输入数据组数。
每组数据包含两行，第一行为去程的 起降 时间，第二行为回程的 起降 时间。
起降时间的格式如下：
```
h1:m1:s1 h2:m2:s2 或 h1:m1:s1 h3:m3:s3 (+1) 或 h1:m1:s1 h4:m4:s4 (+2)
```
表示该航班在当地时间h1时m1分s1秒起飞，
第一种格式表示在当地时间 当日 h2时m2分s2秒降落
第二种格式表示在当地时间 次日 h3时m3分s3秒降落。
第三种格式表示在当地时间 第三天 h4时m4分s4秒降落。
对于此题目中的所有以 h:m:s 形式给出的时间, 保证 ( 0<=h<=23, 0<=m,s<=59 ).
#### 输出格式
输出到标准输出。
对于每一组数据输出一行一个时间hh:mm:ss，表示飞行时间为hh小时mm分ss秒。
注意，当时间为一位数时，要补齐前导零。如三小时四分五秒应写为03:04:05。
#### 样例输入
```
3
17:48:19 21:57:24
11:05:18 15:14:23
17:21:07 00:31:46 (+1)
23:02:41 16:13:20 (+1)
10:19:19 20:41:24
22:19:04 16:41:09 (+1)
```
#### 样例输出
```
04:09:05
12:10:39
14:22:05
```
#### 限制与约定
保证输入时间合法，飞行时间不超过24小时。
#### 资源约定：
峰值内存消耗（含虚拟机）< 256M
CPU消耗 < 1000ms
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/荒岛探测/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 荒岛探测
科学家小蓝来到了一个荒岛，准备对这个荒岛进行探测考察。
小蓝使用了一个超声定位设备来对自己进行定位。为了使用这个设备，小蓝需要在不同的点分别安装一个固定的发射器和一个固定的接收器。小蓝手中还有一个移动设备。定位设备需要从发射器发射一个信号到移动设备，移动设备收到后马上转发，最后由接收器接收，根据这些设备之间传递的时间差就能计算出移动设备距离发射器和接收器的两个距离，从而实现定位。
小蓝在两个位置已经安装了发射器和接收器，其中发射器安装在坐标（$x_A$, $y_A$），接收器安装在坐标（$x_B$, $y_B$）。小蓝的发射器和接收器可能在岛上，也可能不在岛上。
小蓝的定位设备设计有些缺陷，当发射器到移动设备的距离加上移动设备到接收器的距离之和大于L 时，定位设备工作不正常。当和小于等于L时，定位设备工作正常。为了安全，小蓝只在定位设备工作正常的区域探测考察。
已知荒岛是一个三角形，三个顶点的坐标分别为（$x_1$, $y_1$），（$x_2$, $y_2$），（$x_3$, $y_3$）
请计算，小蓝在荒岛上可以探测到的面积有多大？
#### 输入格式
输入的第一行包含五个整数，分别为 $x_A$,$y_A$,$x_B$,$y_B$,L
第二行包含六个整数，分别为 $x_1$,$y_1$,$x_2$,$y_2$,$x_3$,$y_3$ 。
#### 输出格式
输出一行，包含一个实数，四舍五入保留2位小数，表示答案。
考虑到计算中的误差，只要你的输出与参考输出相差不超过0.01即可。
#### 样例输入
```
10 6 4 12 12
0 2 13 2 13 15
```
#### 输出样例
```
39.99
```
#### 样例说明
荒岛的形状和定位设备工作正常的区域如下图所示，蓝色的三角形表示荒岛，红色的曲线围成的区域为定位设备工作正常的区域。 
![](https://img-blog.csdnimg.cn/20210402235557403.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NKTF9hc0xvbmc3Mg==,size_16,color_FFFFFF,t_70#pic_center)
当输出为 39.98、39.99 或 40.00 时可以得分。
#### 评测用例规模与约定
对于所有评测用例，保证发射器的两个坐标不同，$ -1000 \leq x_A,y_A,x_B,y_B\leq 1000$,$ -1000 \leq x_1,y_1,x_2,y_2,x_3,y_3\leq 1000$, $ -1000 \leq L \leq 1000 $。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/蚂蚁感冒/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 蚂蚁感冒
#### 题目描述
长 100 厘米的细长直杆子上有 n 只蚂蚁。
它们的头有的朝左，有的朝右。
每只蚂蚁都只能沿着杆子向前爬，速度是 1 厘米/秒。
当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。
这些蚂蚁中，有 1 只蚂蚁感冒了。
并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。
请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。
#### 输入格式
第一行输入一个整数 n, 表示蚂蚁的总数。
接着的一行是 n 个用空格分开的整数 Xi, Xi 的绝对值表示蚂蚁离开杆子左边端点的距离。
正值表示头朝右，负值表示头朝左，数据中不会出现 0 值，也不会出现两只蚂蚁占用同一位置。
其中，第一个数据代表的蚂蚁感冒了。
#### 输出格式
输出1个整数，表示最后感冒蚂蚁的数目。
#### 数据范围
```
1<n<50,
0<|Xi|<100
```
#### 输入样例1：
```
3
5 -2 8
```
#### 输出样例1：
```
1
```
#### 输入样例2：
```
5
-10 8 -20 12 25
```
#### 输出样例2：
```
3
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/蛇形填数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 蛇形填数
如下图所示，小明用从1 开始的正整数“蛇形”填充无限大的矩阵。
![](https://img-blog.csdnimg.cn/20210221154521571.png)
容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20 行第20 列的数是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/螺旋折线/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 螺旋折线
如图所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(X, Y)，我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。
例如```dis(0, 1)=3, dis(-2, -1)=9```
给出整点坐标(X, Y)，你能计算出dis(X, Y)吗？
#### 输入格式
```
X和Y
对于40%的数据，-1000 <= X, Y <= 1000
对于70%的数据，-100000 <= X， Y <= 100000
对于100%的数据, -1000000000 <= X, Y <= 1000000000
```
#### 输出格式
```
输出dis(X, Y)
```
#### 样例输入
```
0 1
```
#### 样例输出
```
3
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/装饰珠/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 装饰珠
#### 题目描述
在怪物猎人这一款游戏中，玩家可以通过给装备镶嵌不同的装饰珠来获取 相应的技能，以提升自己的战斗能力。
已知猎人身上一共有 6 件装备，每件装备可能有若干个装饰孔，每个装饰孔有各自的等级，可以镶嵌一颗小于等于自身等级的装饰珠 (也可以选择不镶嵌)。
装饰珠有 M 种，编号 1 至 M，分别对应 M 种技能，第 i 种装饰珠的等级为 $L_i$，只能镶嵌在等级大于等于 $L_i$ 的装饰孔中。
对第 i 种技能来说，当装备相应技能的装饰珠数量达到 $K_i$个时，会产生$W_i$($K_i$)的价值，镶嵌同类技能的数量越多，产生的价值越大，即$W_i$($K_{i-1}$)<$W_i$($K_i$)。但每个技能都有上限$P_i$(1≤$P_i$≤7)，当装备的珠子数量超过$P_i$时，只会产生$W_i$($P_i$)的价值。
对于给定的装备和装饰珠数据，求解如何镶嵌装饰珠，使得 6 件装备能得到的总价值达到最大。
#### 输入描述
输入的第 1 至 6 行，包含 6 件装备的描述。其中第i行的第一个整数Ni表示第i件装备的装饰孔数量。后面紧接着Ni个整数，分别表示该装备上每个装饰孔的等级L(1≤ L ≤4)。
第 7 行包含一个正整数 M，表示装饰珠 (技能) 种类数量。
第 8 至 M + 7 行，每行描述一种装饰珠 (技能) 的情况。每行的前两个整数$L_j$(1≤ $L_j$ ≤4)和$P_j$(1≤ $P_j$ ≤7)分别表示第 j 种装饰珠的等级和上限。接下来$P_j$个整数，其中第 k 个数表示装备该中装饰珠数量为 k 时的价值$W_j$(k)。
其中$1 ≤ N_i ≤ 50，1 ≤ M ≤ 10^4，1 ≤ W_j(k) ≤ 10^4。$
#### 输出描述
输出一行包含一个整数，表示能够得到的最大价值。
#### 输入
```
1 1
2 1 2
1 1
2 2 2
1 1
1 3
3
1 5 1 2 3 5 8
2 4 2 4 8 15
3 2 5 10
```
#### 输出
```
20
```
#### 样例说明
按照如下方式镶嵌珠子得到最大价值 20，括号内表示镶嵌的装饰珠的种类编号：
```
1: (1)
2: (1) (2)
3: (1)
4: (2) (2)
5: (1)
6: (2)
```
4 颗技能 1 装饰珠，4 颗技能 2 装饰珠 $W_1(4) + W_2(4) = 5 + 15 = 20。W_1(4)+W_2(4)=5+15=20$。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/解密/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 解密
#### 问题描述
RSA 是一种经典的加密算法。它的基本加密过程如下。
首先生成两个质数 p, q，令 n = p · q，设 d 与 (p − 1) · (q − 1) 互质，则可找到 e 使得 d · e 除 (p − 1) · (q − 1) 的余数为 1。
n, d, e 组成了私钥，n, d 组成了公钥。
当使用公钥加密一个整数 X 时（小于 n），计算 C = Xd mod n，则 C 是加密后的密文。
当收到密文 C 时，可使用私钥解开，计算公式为 X = Ce mod n。
例如，当 p = 5, q = 11, d = 3 时，n = 55, e = 27。
若加密数字 24，得 243 mod 55 = 19。
解密数字 19，得 1927 mod 55 = 24。
现在你知道公钥中 n = 1001733993063167141, d = 212353，同时你截获了别人发送的密文 C = 20190324，请问，原文是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/解码/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 解码
#### 问题描述
小明有一串很长的英文字母，可能包含大写和小写。在这串字母中，有很多连续的是重复的。小明想了一个办法将这串字母表达得更短：将连续的几个相同字母写成字母 + 出现次数的形式。
例如，连续的 5 个 a，即 aaaaa，小明可以简写成 a5（也可能简写成 a4a、aa3a 等）。对于这个例子：HHHellllloo，小明可以简写成 H3el5o2。为了方便表达，小明不会将连续的超过 9 个相同的字符写成简写的形式。
现在给出简写后的字符串，请帮助小明还原成原来的串。
#### 输入格式
输入一行包含一个字符串。
#### 输出格式
输出一个字符串，表示还原后的串。
#### 样例输入
```
H3el5o2
```
#### 样例输出
```
HHHellllloo
```
#### 评测用例规模与约定
对于所有评测用例，字符串由大小写英文字母和数字组成，长度不超过100。
请注意原来的串长度可能超过 100。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/购物单/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 购物单
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。你的任务是计算出，小明最少需要取多少现金。
```
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。
-----------------
**** 180.90 88折
**** 10.25 65折
**** 56.14 9折
**** 104.65 9折
**** 100.30 88折
**** 297.15 半价
**** 26.75 65折
**** 130.62 半价
**** 240.28 58折
**** 270.62 8折
**** 115.87 88折
**** 247.34 95折
**** 73.21 9折
**** 101.00 半价
**** 79.54 半价
**** 278.44 7折
**** 199.26 半价
**** 12.97 9折
**** 166.30 78折
**** 125.50 58折
**** 84.98 9折
**** 113.35 68折
**** 166.57 半价
**** 42.56 9折
**** 81.90 95折
**** 131.78 8折
**** 255.89 78折
**** 109.17 9折
**** 146.69 68折
**** 139.33 65折
**** 141.16 78折
**** 154.74 8折
**** 59.42 8折
**** 85.44 68折
**** 293.70 88折
**** 261.79 65折
**** 11.30 88折
**** 268.27 58折
**** 128.29 88折
**** 251.03 8折
**** 208.39 75折
**** 128.88 75折
**** 62.06 9折
**** 225.87 75折
**** 12.89 75折
**** 34.28 75折
**** 62.16 58折
**** 129.12 半价
**** 218.37 半价
**** 289.69 8折
--------------------
```
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。
请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/走方格/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 走方格
#### 问题描述
在平面上有一些二维的点阵。这些点的编号就像二维数组的编号一样，从上到下依次为第 1 至第 n 行，从左到右依次为第 1 至第 m 列，每一个点可以用行号和列号来表示。现在有个人站在第 1 行第 1 列，要走到第 n 行第 m 列。只能向右或者向下走。注意，如果行号和列数都是偶数，不能走入这一格中。问有多少种方案。
#### 输入格式
输入一行包含两个整数 n, m。
#### 输出格式
输出一个整数，表示答案。
#### 样例输入
```
3 4
```
#### 样例输出
```
2
```
#### 样例输入
```
6 6
```
#### 样例输出
```
0
```
#### 测试数据
对于所有评测用例，1 ≤ n ≤ 30, 1 ≤ m ≤ 30。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/超级胶水/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 超级胶水
小明有n颗石子，按顺序摆成一排。他准备用胶水将这些石子粘在一起。每颗石子有自己的重量，如果将两颗石子粘在一起，将合并成一颗新的石子，重量是这两颗石子的重量之和。
为了保证石子粘贴牢固，粘贴两颗石子所需要的胶水与两颗石子的重量乘积成正比，本题不考虑物理单位，认为所需要的胶水在数值上等于两颗石子重量的乘积。
每次合并，小明只能合并位置相邻的两颗石子，并将合并出的新石子放在原来的位置。
现在，小明想用最少的胶水将所有石子粘在一起，请帮助小明计算最少需要多少胶水。
测试样例
输入
```
3
3 4 5
```
输出
```
47
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/跑步训练/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 跑步训练
小明要做一个跑步训练。
初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。
小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0 ，他就停止锻炼。
请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/跑步锻炼/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 跑步锻炼
小蓝每天都锻炼身体。
正常情况下，小蓝每天跑1千米。如果某天是周一或者月初（1日），为了激励自己，小蓝要跑2千米。如果同时是周一或月初，小蓝也是跑2千米。
小蓝跑步已经坚持了很长时间，从2000年1月1日周六（含）到2020年10月1日周四（含）。请问这段时间小蓝总共跑步多少千米？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/跳蚱蜢/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 跳蚱蜢
有 9 只盘子，排成 1 个圆圈。
其中 8 只盘子内装着 8 只蚱蜢，有一个是空盘，我们把这些蚱蜢顺时针编号为 1 ~ 8
每只蚱蜢都可以跳到相邻的空盘中，也可以再用点力，越过一个相邻的蚱蜢跳到空盘中。
请你计算一下，如果要使得蚱蜢们的队形改为按照逆时针排列，
并且保持空盘的位置不变（也就是 1-8 换位，2-7 换位,…），至少要经过多少次跳跃？
![](https://img-blog.csdnimg.cn/20200530104930106.png)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/连号区间数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 连号区间数
#### 问题描述
小明这些天一直在思考这样一个奇怪而有趣的问题：
在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是：
如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。
当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助。
#### 输入格式
第一行是一个正整数N (1 <= N <= 50000), 表示全排列的规模。
第二行是N个不同的数字Pi(1 <= Pi <= N)， 表示这N个数字的某一全排列。
#### 输出格式
输出一个整数，表示不同连号区间的数目。
#### 样例输入1
```
4
3 2 4 1
```
#### 样例输出1
```
7
```
#### 样例输入2
```
5
3 4 2 5 1
```
#### 样例输出2
```
9
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/迷宫/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 迷宫
#### 问题描述
下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。
```
010000
000100
001001
110000
```
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt， 内容与下面的文本相同）
#### 题目数据
```
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/逆波兰表达式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 逆波兰表达式
正常的表达式称为中缀表达式，运算符在中间，主要是给人阅读的，机器求解并不方便。
例如：3 + 5 * (2 + 6) - 1
而且，常常需要用括号来改变运算次序。
相反，如果使用逆波兰表达式（前缀表达式）表示，上面的算式则表示为：
```
- + 3 * 5 + 2 6 1
```
不再需要括号，机器可以用递归的方法很方便地求解。
为了简便，我们假设：
1. 只有 $ + - * $ 三种运算符
2. 每个运算数都是一个小于10的非负整数
下面的程序对一个逆波兰表示串进行求值。
其返回值为一个数组：其中第一元素表示求值结果，第二个元素表示它已解析的字符数。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/递增三元组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 递增三元组
给定三个整数数组
A = [A1, A2, ... AN],
B = [B1, B2, ... BN],
C = [C1, C2, ... CN]，
请你统计有多少个三元组(i, j, k) 满足：
1. 1 <= i, j, k <= N
2. Ai < Bj < Ck
#### 输入格式
第一行包含一个整数N。
第二行包含N个整数A1, A2, ... AN。
第三行包含N个整数B1, B2, ... BN。
第四行包含N个整数C1, C2, ... CN。
对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000
#### 输出格式
一个整数表示答案
#### 样例输入
```
3
1 1 1
2 2 2
3 3 3
```
#### 样例输出
```
27
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/错误票据/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 错误票据
#### 问题描述
某涉密单位下发了某种票据，并要在年终全部收回。
每张票据有唯一的ID号。全年所有票据的ID号是连续的，但ID的开始数码是随机选定的。
因为工作人员疏忽，在录入ID号的时候发生了一处错误，造成了某个ID断号，另外一个ID重号。
你的任务是通过编程，找出断号的ID和重号的ID。
假设断号不可能发生在最大和最小号。
#### 输入格式
要求程序首先输入一个整数N(N<100)表示后面数据行数。
接着读入N行数据。
每行数据长度不等，是用空格分开的若干个（不大于100个）正整数（不大于100000），请注意行内和行末可能有多余的空格，你的程序需要能处理这些空格。
每个整数代表一个ID号。
#### 输出格式
要求程序输出1行，含两个整数m n，用空格分隔。
其中，m表示断号ID，n表示重号ID
#### 样例输入1
```
2
5 6 8 11 9
10 12 9
```
#### 样例输出1
```
7 9
```
#### 样例输入2
```
6
164 178 108 109 180 155 141 159 104 182 179 118 137 184 115 124 125 129 168 196
172 189 127 107 112 192 103 131 133 169 158
128 102 110 148 139 157 140 195 197
185 152 135 106 123 173 122 136 174 191 145 116 151 143 175 120 161 134 162 190
149 138 142 146 199 126 165 156 153 193 144 166 170 121 171 132 101 194 187 188
113 130 176 154 177 120 117 150 114 183 186 181 100 163 160 167 147 198 111 119
```
#### 样例输出2
```
105 120
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/锦标赛/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 锦标赛
如果要在n个数据中挑选出第一大和第二大的数据（要求输出数据所在位置和值），使用什么方法比较的次数最少？我们可以从体育锦标赛中受到启发。
如图所示，8个选手的锦标赛，先两两捉对比拼，淘汰一半。优胜者再两两比拼...直到决出第一名。
第一名输出后，只要对黄色标示的位置重新比赛即可。
![](https://img-blog.csdn.net/20180325224626876)
下面的代码实现了这个算法（假设数据中没有相同值）。
代码中需要用一个数组来表示图中的树（注意，这是个满二叉树，不足需要补齐）。它不是存储数据本身，而是存储了数据的下标。
第一个数据输出后，它所在的位置被标识为-1
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/门牌制作/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 门牌制作
小蓝要为一条街的住户制作门牌号。
这条街一共有 2020 位住户，门牌号从 1 到 2020 编号。
小蓝制作门牌的方法是先制作 0 到 9 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、7，即需要 1 个字符 0，2 个字符 1，1 个字符 7。
请问要制作所有的 1 到 2020 号门牌，总共需要多少个字符 2？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/颠倒的价牌/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 颠倒的价牌
小李的店里专卖其它店中下架的样品电视机，可称为：样品电视专卖店。
其标价都是4位数字（即千元不等）。
小李为了标价清晰、方便，使用了预制的类似数码管的标价签，只要用颜色笔涂数字就可以了（参见图片）。
![](https://img-blog.csdnimg.cn/20200315215554485.png)
这种价牌有个特点，对一些数字，倒过来看也是合理的数字。如：1 2 5 6 8 9 0 都可以。这样一来，如果牌子挂倒了，有可能完全变成了另一个价格，比如：1958 倒着挂就是：8561，差了几千元啊!!
当然，多数情况不能倒读，比如，1110 就不能倒过来，因为0不能作为开始数字。
有一天，悲剧终于发生了。某个店员不小心把店里的某两个价格牌给挂倒了。并且这两个价格牌的电视机都卖出去了!
庆幸的是价格出入不大，其中一个价牌赔了2百多，另一个价牌却赚了8百多，综合起来，反而多赚了558元。
请根据这些信息计算：赔钱的那个价牌正确的价格应该是多少？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/饮料换购/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 饮料换购
乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去(但不允许暂借或赊账)。
请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能喝到多少瓶饮料。
输入：一个整数n，表示开始购买的饮料数量（0<n<10000）
输出：一个整数，表示实际得到的饮料数
例如：
用户输入：
```
100
```
程序应该输出：
```
149
```
用户输入：
```
101
```
程序应该输出：
```
151
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/马虎的算式/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 马虎的算式
小明是个急性子，上小学的时候经常把老师写在黑板上的题目抄错了。
有一次，老师出的题目是：36 x 495 = ?
他却给抄成了：396 x 45 = ?
但结果却很戏剧性，他的答案竟然是对的！！
因为 36 * 495 = 396 * 45 = 17820
类似这样的巧合情况可能还有很多，比如：27 * 594 = 297 * 54
假设 a b c d e 代表1~9不同的5个数字（注意是各不相同的数字，且不含0）
能满足形如： ab * cde = adb * ce 这样的算式一共有多少种呢？
请你利用计算机的优势寻找所有的可能，并回答不同算式的种类数。
满足乘法交换律的算式计为不同的种类，所以答案肯定是个偶数。
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/高斯日记/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 高斯日记
大数学家高斯有个好习惯：无论如何都要记日记。
他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210
后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？
高斯出生于：1777年4月30日。
在高斯发现的一个重要定理的日记上标注着：5343，因此可算出那天是：1791年12月15日。
高斯获得博士学位的那天日记上标着：8113
请你算出高斯获得博士学位的年月日。
#### 输出格式
提交答案的格式是：yyyy-mm-dd, 例如：1980-03-21
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/魔方模拟/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 魔方模拟
魔方可以对它的6个面自由旋转。
我们来操作一个2阶魔方（如图所示）：
为了描述方便，我们为它建立了坐标系。
各个面的初始状态如下：
```
x轴正向：绿
x轴反向：蓝
y轴正向：红
y轴反向：橙
z轴正向：白
z轴反向：黄
```
假设我们规定，只能对该魔方进行3种操作。分别标记为：
```
x 表示在x轴正向做顺时针旋转
y 表示在y轴正向做顺时针旋转
z 表示在z轴正向做顺时针旋转
```
xyz 则表示顺序执行x,y,z 3个操作
![](https://img-blog.csdn.net/20170113214548029)
![](https://img-blog.csdn.net/20170113214552070)
![](https://img-blog.csdn.net/20170113214558404)
![](https://img-blog.csdn.net/20170113214602149)
题目的要求是：
从标准输入获得一个串，表示操作序列。
程序输出：距离我们最近的那个小方块的3个面的颜色。
顺序是：x面，y面，z面。
例如：在初始状态，应该输出：
绿红白
初始状态下，如果用户输入：
```
x
```
则应该输出：
```
绿白橙
```
初始状态下，如果用户输入：
```
zyx
```
则应该输出：
```
红白绿
```
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/魔方状态/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
```
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色
```
请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态？
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
![](https://img-blog.csdnimg.cn/20201110192355364.png#pic_center)
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/1.算法初阶/1.蓝桥杯/黄金连分数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 黄金连分数
黄金分割数0.61803… 是个无理数，这个常数十分重要，在许多工程问题中会出现。有时需要把这个数字求得很精确。
对于某些精密工程，常数的精度很重要。也许你听说过哈勃太空望远镜，它首次升空后就发现了一处人工加工错误，对那样一个庞然大物，其实只是镜面加工时有比头发丝还细许多倍的一处错误而已，却使它成了“近视眼”!!
言归正传，我们如何求得黄金分割数的尽可能精确的值呢？有许多方法。
比较简单的一种是用连分数：
```
1
黄金数 = ---------------------
1
1 + -----------------
1
1 + -------------
1
1 + ---------
1 + ...
```
这个连分数计算的“层数”越多，它的值越接近黄金分割数。
请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。
小数点后3位的值为：0.618
小数点后4位的值为：0.6180
小数点后5位的值为：0.61803
小数点后7位的值为：0.6180340
(注意尾部的0，不能忽略）
你的任务是：写出精确到小数点后100位精度的黄金分割值。
注意：尾数的四舍五入！ 尾数是0也要保留！
显然答案是一个小数，其小数点后有100位数字
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/10_盛最多水的容器/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 盛最多水的容器
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
int arr1[] = {1, 8, 6, 2, 5, 4, 8, 3, 7};
int length1 = sizeof(arr1) / sizeof(arr1[0]);
vector<int> nums1(arr1, arr1 + length1);
cout << sol.maxArea(nums1) << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int maxArea(vector<int> &height)
{
int res = 0;
for (int i = 0; i < height.size(); i++)
{
for (int j = i + 1; j < height.size(); j++)
{
int temp1 = max(height[i], height[j]);
int temp2 = temp1 * (j - i);
res = min(res, temp2);
}
}
return res;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int maxArea(vector<int> &height)
{
int i = 0;
int j = height.size() - 1;
int res = 0;
while (i < j)
{
int temp1 = min(height[i], height[j]);
int temp2 = temp1 * (j - i);
res = max(res, temp2);
if (height[i] < height[j])
i++;
else
j--;
}
return res;
}
};
```
### B
```cpp
class Solution
{
public:
int maxArea(vector<int> &height)
{
int tmp = 0, res = 0, max = 0;
for (int i = 0; i < height.size(); ++i)
{
for (int j = i + 1; j < height.size(); ++j)
{
if (height[i] < height[j])
{
tmp = height[i];
}
else
{
tmp = height[j];
}
res = tmp * (j - i);
if (res > max)
{
max = res;
}
}
}
return max;
}
};
```
### C
```cpp
class Solution
{
public:
int maxArea(vector<int> &height)
{
int tail = height.size() - 1;
int head = 0;
int maxarea = height.at(head) > height.at(tail) ? height.at(tail) * (tail - head) : height.at(head) * (tail - head);
for (int i = 0; i < height.size(); i++)
{
if (maxarea < (height.at(head) > height.at(tail) ? height.at(tail) * (tail - head) : height.at(head) * (tail - head)))
maxarea = height.at(head) > height.at(tail) ? height.at(tail) * (tail - head) : height.at(head) * (tail - head);
if (height.at(head) > height.at(tail))
{
tail--;
}
else
{
head++;
}
}
return maxarea;
}
};
```
data/3.算法高阶/1.leetcode/11_整数转罗马数字/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 整数转罗马数字
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
cout << sol.intToRoman(1994) << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
string intToRoman(int num)
{
int nums[13] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string romans[13] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
string ans;
int index = 0;
while (index < 13)
{
while (num >= nums[index])
{
num = nums[index];
ans = romans[index];
}
index++;
}
return ans;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
string getNum1000(int num1000)
{
if (num1000 == 3)
{
return "MMM";
}
else if (num1000 == 2)
{
return "MM";
}
else if (num1000 == 1)
{
return "M";
}
else
{
return "";
}
}
string getNum100(int num100)
{
switch (num100)
{
case 1:
return "C";
case 2:
return "CC";
case 3:
return "CCC";
case 4:
return "CD";
case 5:
return "D";
case 6:
return "DC";
case 7:
return "DCC";
case 8:
return "DCCC";
case 9:
return "CM";
default:
return "";
}
}
string getNum10(int num10)
{
switch (num10)
{
case 1:
return "X";
case 2:
return "XX";
case 3:
return "XXX";
case 4:
return "XL";
case 5:
return "L";
case 6:
return "LX";
case 7:
return "LXX";
case 8:
return "LXXX";
case 9:
return "XC";
default:
return "";
}
}
string getNum1(int num1)
{
switch (num1)
{
case 1:
return "I";
case 2:
return "II";
case 3:
return "III";
case 4:
return "IV";
case 5:
return "V";
case 6:
return "VI";
case 7:
return "VII";
case 8:
return "VIII";
case 9:
return "IX";
default:
return "";
}
}
string intToRoman(int num)
{
int num1000 = num / 1000;
int num100 = (num % 1000) / 100;
int num10 = (num % 100) / 10;
int num1 = (num % 10);
string res;
res = getNum1000(num1000) + getNum100(num100) + getNum10(num10) + getNum1(num1);
return res;
}
};
```
### B
```cpp
class Solution
{
public:
string intToRoman(int num)
{
int values[13] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string reps[13] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
string res;
for (int i = 0; i < 13; i++)
{
while (num >= values[i])
{
num -= values[i];
res += reps[i];
}
}
return res;
}
};
```
### C
```cpp
class Solution
{
public:
string intToRoman(int num)
{
string bit1[10] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
string bit10[10] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
string bit100[10] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
string bit1000[4] = {"", "M", "MM", "MMM"};
return bit1000[num / 1000] + bit100[num % 1000 / 100] + bit10[num % 100 / 10] + bit1[num % 10];
}
};
```
data/3.算法高阶/1.leetcode/12_罗马数字转整数/desc.html
浏览文件 @ 46e221cd
<div class="notranslate"> <p>罗马数字包含以下七种字符: <code>I</code>， <code>V</code>， <code>X</code>， <code>L</code>，<code>C</code>，<code>D</code> 和 <code>M</code>。
<p>罗马数字包含以下七种字符：&nbsp;<code>I</code>，&nbsp;<code>V</code>，&nbsp;<code>X</code>，&nbsp;<code>L</code>，<code>C</code>，<code>D</code>&nbsp;和&nbsp;<code>M</code>。 </p>
</p>
<pre><strong>字符</strong> <strong>数值</strong> <pre>
<strong>字符</strong> <strong>数值</strong>
I 1 I 1
V 5 V 5
X 10 X 10
...@@ -11,59 +11,66 @@ C 100 ...@@ -11,59 +11,66 @@ C 100
D 500 D 500
M 1000</pre> M 1000</pre>
<p>例如， 罗马数字 2 写做&nbsp;<code>II</code>&nbsp;，即为两个并列的 1。12 <p>例如， 罗马数字 2 写做 <code>II</code> ，即为两个并列的 1。12 写做 <code>XII</code> ，即为 <code>X</code> + <code>II</code> 。 27
写做&nbsp;<code>XII</code>&nbsp;，即为&nbsp;<code>X</code>&nbsp;+&nbsp;<code>II</code>&nbsp;。 27 写做  <code>XXVII</code>, 即为 <code>XX</code> + <code>V</code> + <code>II</code> 。</p>
写做&nbsp;&nbsp;<code>XXVII</code>,
即为&nbsp;<code>XX</code>&nbsp;+&nbsp;<code>V</code>&nbsp;+&nbsp;<code>II</code>&nbsp;。</p>
<p>通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做&nbsp;<code>IIII</code>，而是&nbsp;<code>IV</code>。数字 1 在数字 5 的左边，所表示的数等于大数 5 <p>通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 <code>IIII</code>，而是 <code>IV</code>。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4
减小数 1 得到的数值 4 。同样地，数字 9 表示为&nbsp;<code>IX</code>。这个特殊的规则只适用于以下六种情况：</p> 。同样地，数字 9 表示为 <code>IX</code>。这个特殊的规则只适用于以下六种情况：</p>
<ul> <ul>
<li><code>I</code>&nbsp;可以放在&nbsp;<code>V</code>&nbsp;(5) 和&nbsp;<code>X</code>&nbsp;(10) 的左边，来表示 4 和 9。</li> <li><code>I</code> 可以放在 <code>V</code> (5) 和 <code>X</code> (10) 的左边，来表示 4 和 9。</li>
<li><code>X</code>&nbsp;可以放在&nbsp;<code>L</code>&nbsp;(50) 和&nbsp;<code>C</code>&nbsp;(100) 的左边，来表示 40 <li><code>X</code> 可以放在 <code>L</code> (50) 和 <code>C</code> (100) 的左边，来表示 40 和 90。 </li>
和&nbsp;90。&nbsp;</li> <li><code>C</code> 可以放在 <code>D</code> (500) 和 <code>M</code> (1000) 的左边，来表示 400 和 900。</li>
<li><code>C</code>&nbsp;可以放在&nbsp;<code>D</code>&nbsp;(500) 和&nbsp;<code>M</code>&nbsp;(1000) 的左边，来表示&nbsp;400 </ul>
和&nbsp;900。</li>
</ul>
<p>给你一个整数，将其转为罗马数字。</p> <p>给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。</p>
<p>&nbsp;</p> <p> </p>
<p><strong>示例&nbsp;1:</strong></p> <p><strong>示例 1:</strong></p>
<pre><strong>输入:</strong>&nbsp;num = 3 <pre>
<strong><br />输出:</strong> "III"</pre> <strong>输入:</strong> "III"
<strong>输出:</strong> 3</pre>
<p><strong>示例&nbsp;2:</strong></p> <p><strong>示例 2:</strong></p>
<pre><strong>输入:</strong>&nbsp;num = 4 <pre>
<strong><br />输出:</strong> "IV"</pre> <strong>输入:</strong> "IV"
<strong>输出:</strong> 4</pre>
<p><strong>示例&nbsp;3:</strong></p> <p><strong>示例 3:</strong></p>
<pre><strong>输入:</strong>&nbsp;num = 9 <pre>
<strong><br />输出:</strong> "IX"</pre> <strong>输入:</strong> "IX"
<strong>输出:</strong> 9</pre>
<p><strong>示例&nbsp;4:</strong></p> <p><strong>示例 4:</strong></p>
<pre><strong>输入:</strong>&nbsp;num = 58 <pre>
<strong><br />输出:</strong> "LVIII" <strong>输入:</strong> "LVIII"
<strong><br />解释:</strong> L = 50, V = 5, III = 3. <strong>输出:</strong> 58
</pre> <strong>解释:</strong> L = 50, V= 5, III = 3.
</pre>
<p><strong>示例&nbsp;5:</strong></p> <p><strong>示例 5:</strong></p>
<pre><strong>输入:</strong>&nbsp;num = 1994 <pre>
<strong><br />输出:</strong> "MCMXCIV" <strong>输入:</strong> "MCMXCIV"
<strong><br />解释:</strong> M = 1000, CM = 900, XC = 90, IV = 4.</pre> <strong>输出:</strong> 1994
<strong>解释:</strong> M = 1000, CM = 900, XC = 90, IV = 4.</pre>
<p>&nbsp;</p> <p> </p>
<p><strong>提示：</strong></p> <p><strong>提示：</strong></p>
<ul> <ul>
<li><code>1 &lt;= num &lt;= 3999</code></li> <li><code>1 <= s.length <= 15</code></li>
</ul> <li><code>s</code> 仅含字符 <code>('I', 'V', 'X', 'L', 'C', 'D', 'M')</code></li>
</div> <li>题目数据保证 <code>s</code> 是一个有效的罗马数字，且表示整数在范围 <code>[1, 3999]</code> 内</li>
\ No newline at end of file <li>题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。</li>
<li>IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。</li>
<li>关于罗马数字的详尽书写规则，可以参考 <a
href="https://b2b.partcommunity.com/community/knowledge/zh_CN/detail/10753/%E7%BD%97%E9%A9%AC%E6%95%B0%E5%AD%97#knowledge_article">罗马数字
- Mathematics </a>。</li>
</ul>
\ No newline at end of file
data/3.算法高阶/1.leetcode/12_罗马数字转整数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 罗马数字转整数
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
cout << sol.romanToInt("LVIII") << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int getTwoNum(char num1, char num2)
{
if (num1 == 'I' && (num2 == 'V' || num2 == 'X'))
{
if (num2 == 'V')
{
return 4;
}
else
{
return 9;
}
}
if (num1 == 'X' && (num2 == 'L' || num2 == 'C'))
{
if (num2 == 'L')
{
return 40;
}
else
{
return 90;
}
}
if (num1 == 'C' && (num2 == 'D' || num2 == 'M'))
{
if (num2 == 'D')
{
return 400;
}
else
{
return 900;
}
}
else
{
return -1;
}
}
int romanToInt(string s)
{
int index = 0;
int sum = 0;
while (index < s.length())
{
char romeNum1 = s[index];
if (index == s.length())
{
sum = getNum(romeNum1);
}
else
{
char romeNum2 = s[index + 1];
int twosum = getTwoNum(romeNum1, romeNum2);
if (twosum > 0)
{
sum += twosum;
index++;
}
else
{
sum = getNum(romeNum1);
}
}
index++;
}
return sum;
}
private:
int getNum(char roma)
{
switch (roma)
{
case 'I':
return 1;
case 'V':
return 5;
case 'X':
return 10;
case 'L':
return 50;
case 'C':
return 100;
case 'D':
return 500;
case 'M':
return 1000;
default:
return 0;
}
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int romanToInt(string s)
{
int result = 0;
int n = s.length();
for (int i = 0; i < n; i++)
{
switch (s[i])
{
case 'I':
if (i < n - 1 && s[i + 1] == 'V')
{
result += 4;
i++;
}
else if (i < n - 1 && s[i + 1] == 'X')
{
result += 9;
i++;
}
else
result++;
break;
case 'V':
result += 5;
break;
case 'X':
if (i < n - 1 && s[i + 1] == 'L')
{
result += 40;
i++;
}
else if (i < n - 1 && s[i + 1] == 'C')
{
result += 90;
i++;
}
else
result += 10;
break;
case 'L':
result += 50;
break;
case 'C':
if (i < n - 1 && s[i + 1] == 'D')
{
result += 400;
i++;
}
else if (i < n - 1 && s[i + 1] == 'M')
{
result += 900;
i++;
}
else
result += 100;
break;
case 'D':
result += 500;
break;
case 'M':
result += 1000;
}
}
return result;
}
};
```
### B
```cpp
class Solution
{
public:
int romanToInt(string s)
{
int result = 0;
map<char, int> luomab;
luomab.insert(map<char, int>::value_type('I', 1));
luomab.insert(map<char, int>::value_type('V', 5));
luomab.insert(map<char, int>::value_type('X', 10));
luomab.insert(map<char, int>::value_type('L', 50));
luomab.insert(map<char, int>::value_type('C', 100));
luomab.insert(map<char, int>::value_type('D', 500));
luomab.insert(map<char, int>::value_type('M', 1000));
for (int i = 0; i < s.length(); i++)
{
if (luomab[s[i]] >= luomab[s[i + 1]])
result += luomab[s[i]];
else
{
result += (luomab[s[i + 1]] - luomab[s[i]]);
i++;
}
}
return result;
}
};
```
### C
```cpp
class Solution
{
public:
int romanToInt(string s)
{
int sum = 0;
for (int i = 1; i <= s.size(); i++)
{
if (s[i - 1] == 'I' && s[i] == 'V')
{
sum += 4;
i++;
}
else if (s[i - 1] == 'I' && s[i] == 'X')
{
sum += 9;
i++;
}
else if (s[i - 1] == 'X' && s[i] == 'L')
{
sum += 40;
i++;
}
else if (s[i - 1] == 'X' && s[i] == 'C')
{
sum += 90;
i++;
}
else if (s[i - 1] == 'C' && s[i] == 'D')
{
sum += 400;
i++;
}
else if (s[i - 1] == 'C' && s[i] == 'M')
{
sum += 900;
i++;
}
else if (s[i - 1] == 'I')
{
sum += 1;
}
else if (s[i - 1] == 'V')
{
sum += 5;
}
else if (s[i - 1] == 'X')
{
sum += 10;
}
else if (s[i - 1] == 'L')
{
sum += 50;
}
else if (s[i - 1] == 'C')
{
sum += 100;
}
else if (s[i - 1] == 'D')
{
sum += 500;
}
else if (s[i - 1] == 'M')
{
sum += 1000;
}
}
return sum;
}
};
```
data/3.算法高阶/1.leetcode/13_最长公共前缀/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最长公共前缀
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
string arr[] = {"flower", "flow", "flight"};
int length1 = sizeof(arr) / sizeof(arr[0]);
vector<string> strs(arr, arr + length1);
cout << sol.longestCommonPrefix(strs) << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
string longestCommonPrefix(vector<string> &strs)
{
if (strs.empty())
return "";
if (strs.size() == 1)
return strs[0];
sort(strs.begin(), strs.end());
string s1 = strs[0], s2 = strs.back();
for (int i = 0; i < s1.size(); ++i)
{
if (i == s2.size())
return s1.substr(0, i);
}
return s1;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
string longestCommonPrefix(vector<string> &strs)
{
string ans;
int i, j, flag = 0, n = strs.size();
if (n == 0)
return "";
for (i = 0; i < strs[0].length(); i++)
{
char ch = strs[0][i];
for (j = 1; j < n; j++)
{
if (i >= strs[j].length() || ch != strs[j][i])
{
flag = 1;
break;
}
}
if (flag)
break;
if (j == n)
{
string x;
x = ch;
ans.append(x);
}
}
return ans;
}
};
```
### B
```cpp
class Solution
{
public:
string longestCommonPrefix(vector<string> &strs)
{
int len;
string str, temp;
if (strs.size() == 0)
return "";
temp = strs[0];
for (int i = 1; i < strs.size(); i++)
{
str = strs[i];
string p = "";
if (temp.size() < str.size())
len = temp.size();
else
len = str.size();
for (int j = 0; j < len; j++)
{
if (temp[j] == str[j])
{
p = p + str[j];
continue;
}
else
break;
}
temp = p;
}
return temp;
}
};
```
### C
```cpp
class Solution
{
public:
string longestCommonPrefix(vector<string> &strs)
{
int sLen = strs.size();
if (sLen == 0)
return "";
string dst = "";
int minLen = 100;
int minIndex = 0;
for (int i = 0; i < sLen; ++i)
{
int len = strs[i].length();
if (len < minLen)
{
minLen = len;
minIndex = i;
}
}
for (int i = 0; i < strs[minIndex].length(); ++i)
{
set<char> ch;
for (auto iter : strs)
ch.insert((iter)[i]);
int setLens = ch.size();
if (setLens > 1)
break;
if (setLens == 1)
dst += *ch.begin();
}
return dst;
}
};
```
data/3.算法高阶/1.leetcode/14_三数之和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 三数之和
以下错误的选项是？
## aop
### before
```cpp
#include <vector>
#include <iostream>
#include <set>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
int arr[] = {-1,0,1,2,-1,-4};
int length1 = sizeof(arr) / sizeof(arr[0]);
vector<int> nums(arr, arr + length1);
vector<vector<int> > res;
res = sol.threeSum(nums);
for (auto i : res)
{
for (auto j : i)
cout << j << ' ';
cout << endl;
}
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
vector<vector<int>> threeSum(vector<int> &nums)
{
sort(nums.begin(), nums.end());
int len = nums.size();
vector<vector<int>> ans;
if (nums.empty())
return {};
for (int i = 0; i < len; ++i)
{
if (i > 0 && nums[i] == nums[i - 1])
continue;
int newtar = -nums[i];
int low = i + 1;
int high = len - 1;
while (low < high)
{
if (nums[low] + nums[high] == newtar)
{
ans.push_back({nums[i], nums[low], nums[high]});
while (low < high && nums[low] == nums[low + 1])
++low;
while (low < high && nums[high] == nums[high - 1])
--high;
}
else
high--;
}
}
return ans;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
vector<vector<int>> threeSum(vector<int> &nums)
{
sort(nums.begin(), nums.end());
if (nums.size() < 3 || nums.front() > 0 || nums.back() < 0)
return {};
vector<vector<int>> res;
for (int i = 0; i < nums.size(); i++)
{
int fix = nums[i];
if (fix > 0)
break;
if (i > 0 && fix == nums[i - 1])
continue;
int l = i + 1;
int r = nums.size() - 1;
while (l < r)
{
if (nums[l] + nums[r] == -fix)
{
if (l == i + 1 || r == nums.size() - 1)
{
res.push_back(vector<int>{nums[i], nums[l], nums[r]});
l++;
r--;
}
else if (nums[l] == nums[l - 1])
l++;
else if (nums[r] == nums[r + 1])
r--;
else
{
res.push_back(vector<int>{nums[i], nums[l], nums[r]});
l++;
r--;
}
}
else if (nums[l] + nums[r] < -fix)
l++;
else
r--;
}
}
return res;
}
};
```
### B
```cpp
class Solution
{
public:
static bool cmp(const int &a, const int &b)
{
return a < b;
}
vector<vector<int>> threeSum(vector<int> &nums)
{
sort(nums.begin(), nums.end(), cmp);
vector<int>::iterator it;
vector<vector<int>> res;
set<vector<int>> a;
for (int i = 0; i < nums.size(); i++)
{
if (nums[i] > 0)
break;
for (int j = i + 1; j < nums.size(); j++)
{
it = find(nums.begin() + j + 1, nums.end(), 0 - nums[i] - nums[j]);
if (it != nums.end())
{
vector<int> temp;
temp.push_back(nums[i]);
temp.push_back(nums[j]);
temp.push_back(*it);
a.insert(temp);
}
}
}
for (auto k : a)
{
res.push_back(k);
}
return res;
}
};
```
### C
```cpp
class Solution
{
public:
vector<vector<int> > threeSum(vector<int> &nums)
{
if (nums.size() < 3)
return {};
vector<vector<int> > res;
set<vector<int> > ret;
for (int i = 0; i < nums.size() - 2; i++)
{
for (int j = i + 1; j < nums.size() - 1; j++)
{
for (int k = j + 1; k < nums.size(); k++)
{
if (nums[i] + nums[k] + nums[j] == 0)
{
vector<int> temp;
int a = (nums[i] < nums[j] ? nums[i] : nums[j]) < nums[k] ? (nums[i] < nums[j] ? nums[i] : nums[j]) : nums[k];
int b = (nums[i] > nums[j] ? nums[i] : nums[j]) > nums[k] ? (nums[i] > nums[j] ? nums[i] : nums[j]) : nums[k];
int c = 0 - a - b;
temp.push_back(a);
temp.push_back(c);
temp.push_back(b);
ret.insert(temp);
}
}
}
}
for (auto it : ret)
{
res.push_back(it);
}
return res;
}
};
```
data/3.算法高阶/1.leetcode/15_最接近的三数之和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最接近的三数之和
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
int arr[] = {-1, 2, 1, -4};
int target = 1;
int length1 = sizeof(arr) / sizeof(arr[0]);
vector<int> nums(arr, arr + length1);
int res;
res = sol.threeSumClosest(nums, target);
cout << res;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int threeSumClosest(vector<int> &nums, int target)
{
if (nums.size() < 3)
;
runtime_error("No Solution");
sort(nums.begin(), nums.end());
int res = nums[0] + nums[1] + nums[2];
int dValue = abs(target - res);
int l, r, sum;
for (int i = 0; i < nums.size() - 2; ++i)
{
l = i + 1;
r = nums.size() - 1;
if (3 * nums[i] > target)
break;
while (l < r)
{
sum = nums[i] + nums[l] + nums[r];
if (sum < target)
--l;
else if (sum > target)
++r;
else
return target;
if (abs(target - sum) < dValue)
{
res = sum;
dValue = abs(target - sum);
}
}
}
return res;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int threeSumClosest(vector<int> &nums, int target)
{
int l = nums.size();
int best = nums[0] + nums[1] + nums[2];
for (int i = 0; i < l - 2; i++)
{
for (int j = i + 1; j < l - 1; j++)
{
for (int k = j + 1; k < l; k++)
{
int t = nums[i] + nums[j] + nums[k];
if (abs(t - target) < abs(best - target))
{
best = t;
}
}
}
}
return best;
}
};
```
### B
```cpp
class Solution
{
public:
int threeSumClosest(vector<int> &nums, int target)
{
sort(nums.begin(), nums.end());
if (nums.size() < 3)
return {};
int closest = target + 10000000;
for (int i = 0; i < nums.size() - 2; i++)
{
int fix = nums[i];
if (fix > target && abs(fix + nums[i + 1] + nums[i + 2] - target) > abs(closest - target))
break;
for (int j = i + 1; j < nums.size() - 1; j++)
{
for (int k = j + 1; k < nums.size(); k++)
{
int temp = abs(target - fix - nums[j] - nums[k]);
if (temp < abs(closest - target))
closest = fix + nums[j] + nums[k];
}
}
}
return closest;
}
};
```
### C
```cpp
class Solution
{
public:
int threeSumClosest(vector<int> &nums, int target)
{
int len = nums.size();
int min = target + 1000000;
sort(nums.begin(), nums.end());
for (int i = 0; i < len; i++)
{
int fir = nums[i];
int r = len - 1;
int l = i + 1;
if (i > 0 && fir == nums[i - 1])
continue;
if (l >= r)
break;
while (l < r)
{
if (nums[l] + nums[r] + fir == target)
return target;
if (nums[l] + nums[r] < target - fir)
{
int temp = target - fir - nums[r] - nums[l];
if (temp < abs(min - target))
min = nums[l] + nums[r] + fir;
l++;
}
else if (nums[l] + nums[r] > target - fir)
{
int temp = nums[l] + nums[r] + fir - target;
if (temp < abs(min - target))
min = nums[l] + nums[r] + fir;
r--;
}
}
}
return min;
}
};
```
data/3.算法高阶/1.leetcode/16_电话号码的字母组合/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 电话号码的字母组合
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
string digits = "23";
vector<string> res;
res = sol.letterCombinations(digits);
for (auto i : res)
cout << i + ' ';
return 0;
}
```
## 答案
```cpp
string letterMap[10] = {" ", " ", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
class Solution
{
public:
void combinStr(const string &digits, size_t index, const string &str, vector<string> &strs)
{
if (index == digits.size())
{
strs.push_back(str);
return;
}
string letters = letterMap[digits[index] - '0'];
for (size_t i = 0; i < letters.size(); i++)
{
combinStr(digits, index, str + letters[i], strs);
}
}
vector<string> letterCombinations(string digits)
{
vector<string> strs;
if (digits.empty())
return strs;
size_t index = 0;
string str;
combinStr(digits, index, str, strs);
return strs;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
vector<string> result;
vector<string> letterCombinations(string digits)
{
string temp;
if (digits.length() == 0)
return result;
getAns(digits, 0, temp, result);
return result;
}
void getAns(string digits, int start, string temp, vector<string> &result)
{
if (temp.size() == digits.length())
result.push_back(temp);
else
{
vector<char> let = getLet(digits[start]);
for (int i = 0; i < let.size(); i++)
{
temp.append(1, let[i]);
getAns(digits, start + 1, temp, result);
temp.pop_back();
}
}
}
vector<char> getLet(char i)
{
vector<char> let;
if (i == '2')
{
let.push_back('a');
let.push_back('b');
let.push_back('c');
}
else if (i == '3')
{
let.push_back('d');
let.push_back('e');
let.push_back('f');
}
else if (i == '4')
{
let.push_back('g');
let.push_back('h');
let.push_back('i');
}
else if (i == '5')
{
let.push_back('j');
let.push_back('k');
let.push_back('l');
}
else if (i == '6')
{
let.push_back('m');
let.push_back('n');
let.push_back('o');
}
else if (i == '7')
{
let.push_back('p');
let.push_back('q');
let.push_back('r');
let.push_back('s');
}
else if (i == '8')
{
let.push_back('t');
let.push_back('u');
let.push_back('v');
}
else if (i == '9')
{
let.push_back('w');
let.push_back('x');
let.push_back('y');
let.push_back('z');
}
return let;
}
};
```
### B
```cpp
class Solution
{
public:
unordered_map<char, string> map = {{'2', "abc"}, {'3', "def"}, {'4', "ghi"}, {'5', "jkl"}, {'6', "mno"}, {'7', "pqrs"}, {'8', "tuv"}, {'9', "wxyz"}};
vector<string> res;
void backtrack(string &s, int index, string cur)
{
if (index == s.size())
{
res.push_back(cur);
return;
}
for (int i = 0; i < map[s[index]].size(); ++i)
backtrack(s, index + 1, cur + map[s[index]][i]);
}
vector<string> letterCombinations(string digits)
{
if (digits.size() == 0)
return res;
string cur;
backtrack(digits, 0, cur);
return res;
}
};
```
### C
```cpp
class Solution
{
public:
vector<string> letterCombinations(string digits)
{
if (digits.size() == 0)
return {};
map<char, string> a;
a.insert(map<char, string>::value_type('2', "abc"));
a.insert(map<char, string>::value_type('3', "def"));
a.insert(map<char, string>::value_type('4', "ghi"));
a.insert(map<char, string>::value_type('5', "jkl"));
a.insert(map<char, string>::value_type('6', "mno"));
a.insert(map<char, string>::value_type('7', "pqrs"));
a.insert(map<char, string>::value_type('8', "tuv"));
a.insert(map<char, string>::value_type('9', "wxyz"));
int count = 1;
for (int i = 0; i < digits.size(); i++)
{
count *= a[digits[i]].size();
}
vector<string> res(count);
count = 1;
for (int i = 0; i < digits.size(); i++)
{
int index = 0;
vector<string> temp(res.begin(), res.begin() + count);
for (int k = 0; k < count; k++)
{
for (auto c : a[digits[i]])
{
res[index] = temp[k] + c;
index++;
}
}
count *= a[digits[i]].size();
}
return res;
}
};
```
data/3.算法高阶/1.leetcode/17_四数之和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 四数之和
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
int target = 0;
int nums[] = {1, 0, -1, 0, -2, 2};
int length1 = sizeof(nums) / sizeof(nums[0]);
vector<int> nums1(nums, nums + length1);
vector<vector<int>> res;
res = sol.fourSum(nums1, target);
for (auto i : res)
{
for (auto j : i)
cout << j << ' ';
cout << endl;
}
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
vector<vector<int>> fourSum(vector<int> &nums, int target)
{
vector<vector<int>> res;
vector<int> temp;
sort(nums.begin(), nums.end());
for (int base_begin = 0; base_begin < nums.size(); base_begin++)
{
if (base_begin > 0 && nums.at(base_begin) == nums.at(base_begin - 1))
continue;
for (int base_end = nums.size() - 1; base_end > base_begin + 2; base_end--)
{
int left = base_begin + 1;
int right = base_end - 1;
while (left < right)
{
int tt = nums.at(base_begin) + nums.at(base_end) + nums.at(left) + nums.at(right);
if (tt > target)
right--;
else
{
temp.clear();
temp.push_back(nums.at(base_begin));
temp.push_back(nums.at(left));
temp.push_back(nums.at(right));
temp.push_back(nums.at(base_end));
res.push_back(temp);
++left;
--right;
}
}
}
}
return res;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
vector<vector<int>> fourSum(vector<int> &nums, int target)
{
vector<vector<int>> res;
sort(nums.begin(), nums.end());
if (nums.size() < 4)
return res;
for (int a = 0; a < nums.size() - 3; ++a)
{
if (a > 0 && nums[a] == nums[a - 1])
{
continue;
}
for (int b = a + 1; b < nums.size() - 2; ++b)
{
if (b > a + 1 && nums[b] == nums[b - 1])
{
continue;
}
int c = b + 1, d = nums.size() - 1;
while (c < d)
{
int sum = nums[a] + nums[b] + nums[c] + nums[d];
if (sum < target)
{
c++;
}
else if (sum > target)
{
d--;
}
else
{
res.push_back({nums[a], nums[b], nums[c], nums[d]});
while (c < d && nums[c] == nums[c + 1])
{
c++;
}
while (c < d && nums[d - 1] == nums[d])
{
d--;
}
c++;
d--;
}
}
}
}
return res;
}
};
```
### B
```cpp
class Solution
{
public:
vector<vector<int>> fourSum(vector<int> &nums, int target)
{
if (nums.size() < 4)
return {};
sort(nums.begin(), nums.end());
vector<vector<int>> res;
set<vector<int>> a;
for (int i = 0; i < nums.size() - 3; i++)
{
if (nums[i] > target && target > 0)
break;
for (int j = i + 1; j < nums.size() - 2; j++)
{
int l = j + 1;
int r = nums.size() - 1;
while (l < r)
{
if (nums[i] + nums[j] + nums[l] + nums[r] < target)
l++;
else if (nums[i] + nums[j] + nums[l] + nums[r] > target)
r--;
else
{
vector<int> temp{nums[i], nums[j], nums[l], nums[r]};
a.insert(temp);
l++;
r--;
}
}
}
}
for (auto c : a)
{
res.push_back(c);
}
return res;
}
};
```
### C
```cpp
class Solution
{
public:
vector<vector<int>> fourSum(vector<int> &nums, int target)
{
if (nums.size() < 4)
return {};
sort(nums.begin(), nums.end());
set<vector<int>> a;
vector<vector<int>> res;
for (int i = 0; i < nums.size() - 3; i++)
{
if (nums[i] > target && target > 0)
break;
for (int j = i + 1; j < nums.size() - 2; j++)
{
for (int l = j + 1; l < nums.size() - 1; l++)
{
for (int r = l + 1; r < nums.size(); r++)
{
if (nums[i] + nums[j] + nums[l] + nums[r] == target)
a.insert(vector<int>{nums[i], nums[j], nums[l], nums[r]});
}
}
}
}
for (auto c : a)
{
res.push_back(c);
}
return res;
}
};
```
data/3.算法高阶/1.leetcode/18_删除链表的倒数第 N 个结点/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 删除链表的倒数第 N 个结点
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
int val;
struct ListNode *next;
ListNode() : val(0), next(nullptr){};
ListNode(int x) : val(x), next(nullptr){};
ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp
int main()
{
Solution sol;
int n = 2;
ListNode *L1 = new ListNode();
ListNode *l11 = new ListNode(1);
ListNode *l12 = new ListNode(2);
ListNode *l13 = new ListNode(3);
ListNode *l14 = new ListNode(4);
ListNode *l15 = new ListNode(5);
L1->next = l11;
l11->next = l12;
l12->next = l13;
l13->next = l14;
l14->next = l15;
ListNode *res = new ListNode();
res = sol.removeNthFromEnd(L1, n);
ListNode *p = res->next;
while (p != NULL)
{
cout << p->val << " ";
p = p->next;
}
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
ListNode *removeNthFromEnd(ListNode *head, int n)
{
if (head->next == NULL)
{
delete head;
return NULL;
}
ListNode *fast = head;
ListNode *slow = head;
for (int i = 0; i < n; ++i)
fast = fast->next;
if (fast == NULL)
{
ListNode *temp = head->next;
head->val = temp->val;
head->next = temp->next;
return head;
}
while (fast->next != NULL)
{
fast = fast->next;
slow = slow->next;
}
slow = slow->next;
return head;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
ListNode *removeNthFromEnd(ListNode *head, int n)
{
auto dummy = new ListNode(0);
dummy->next = head;
auto lst = head;
int len = 0;
while (lst != NULL)
{
++len;
lst = lst->next;
}
int target = len + 1 - n;
lst = dummy;
while (target > 1)
{
lst = lst->next;
--target;
}
lst->next = lst->next->next;
return dummy->next;
}
};
```
### B
```cpp
class Solution
{
public:
ListNode *removeNthFromEnd(ListNode *head, int n)
{
ListNode *h = new ListNode(0);
h->next = head;
ListNode *p = h;
ListNode *k = h;
if (head->next == NULL)
return {};
for (int i = 0; i <= n; i++)
{
k = k->next;
}
while (k)
{
p = p->next;
k = k->next;
}
p->next = p->next->next;
return h->next;
}
};
```
### C
```cpp
class Solution
{
public:
ListNode *removeNthFromEnd(ListNode *head, int n)
{
int count = 0;
ListNode *p = head;
while (p)
{
count++;
p = p->next;
}
p = head;
if (count == 1)
return {};
else if (count - n == 0)
return head->next;
else
{
for (int i = 1; i < count - n; i++)
{
p = p->next;
}
p->next = p->next->next;
}
return head;
}
};
```
data/3.算法高阶/1.leetcode/19_有效的括号/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 有效的括号
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
string s = "([)]";
bool res;
res = sol.isValid(s);
cout << res;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
bool isValid(string s)
{
stack<char> symbols;
for (int i = 0; i < s.size(); i++)
{
if (s[i] == '(' || s[i] == '[' || s[i] == '{')
symbols.push(s[i + 1]);
else
{
if (symbols.size() == 0)
return false;
char match;
if (s[i] == ')')
match = '(';
else if (s[i] == ']')
match = '[';
else if (s[i] == '}')
match = '{';
char c = symbols.top();
symbols.pop();
if (c != match)
return false;
}
}
if (symbols.size() != 0)
return false;
return true;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
bool isValid(string s)
{
if (s.size() % 2 != 0)
return false;
if (s.size() == 0)
return true;
string temp;
temp.push_back(s[0]);
for (int i = 1; i < s.size(); ++i)
{
int k = temp.size() - 1;
if (temp[k] == '(' && s[i] == ')')
temp.pop_back();
else if (temp[k] == '[' && s[i] == ']')
temp.pop_back();
else if (temp[k] == '{' && s[i] == '}')
temp.pop_back();
else
temp.push_back(s[i]);
}
return temp.size() == 0;
}
};
```
### B
```cpp
class Solution
{
public:
bool isValid(string s)
{
if (s.length() == 0)
{
return true;
}
if (s.length() % 2 != 0)
{
return false;
}
stack<char> st;
for (auto item : s)
{
if (item == '(' || item == '[' || item == '{')
st.push(item);
if (st.empty())
return false;
if (item == ')')
{
if (st.top() == '(')
{
st.pop();
}
else
return false;
}
else if (item == ']')
{
if (st.top() == '[')
{
st.pop();
}
else
return false;
}
else if (item == '}')
{
if (st.top() == '{')
{
st.pop();
}
else
return false;
}
}
return st.empty();
}
};
```
### C
```cpp
class Solution
{
public:
bool isValid(string s)
{
stack<char> data;
map<char, char> match = {{'{', '}'}, {'[', ']'}, {'(', ')'}};
for (auto &i : s)
{
if (i == '(' || i == '[' || i == '{')
{
/* code */
data.push(i);
}
else
{
if (data.empty())
return false;
char top = data.top();
data.pop();
if (match[top] != i)
return false;
}
}
return data.size() == 0;
}
};
```
data/3.算法高阶/1.leetcode/1_两数相加/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 两数相加
以下错误的选项是？
## aop
### before
```cpp
#include <unordered_map>
#include <vector>
#include <iostream>
#include <map>
using namespace std;
struct ListNode
{
int val;
struct ListNode *next;
ListNode() : val(0), next(nullptr){};
ListNode(int x) : val(x), next(nullptr){};
ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp
int main()
{
Solution test;
ListNode *L1 = new ListNode();
ListNode *l11 = new ListNode(2);
ListNode *l12 = new ListNode(4);
ListNode *l13 = new ListNode(3);
L1->next = l11;
l11->next = l12;
l12->next = l13;
ListNode *L2 = new ListNode();
ListNode *l21 = new ListNode(5);
ListNode *l22 = new ListNode(6);
ListNode *l23 = new ListNode(4);
L2->next = l21;
l21->next = l22;
l22->next = l23;
ListNode *ret = new ListNode();
ret = test.addTwoNumbers(L1, L2);
ListNode *p = ret->next;
while (p != NULL)
{
cout << p->val << endl;
p = p->next;
}
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
{
ListNode *l3 = new ListNode(0);
ListNode *p1 = l1;
ListNode *p2 = l2;
ListNode *p3 = l3;
int sum = 0, carry = 0;
while (p1 != NULL || p2 != NULL)
{
int x = (p1 != NULL) ? p1->val : 0;
int y = (p2 != NULL) ? p2->val : 0;
sum = x + y + carry;
carry = sum / 10;
p3->next = new ListNode(sum % 10);
p3 = p3->next;
if (p1 != NULL)
{
p1 = p1->next;
}
if (p2 != NULL)
{
p2 = p2->next;
}
}
if (carry == 0)
{
p3->next = new ListNode(carry);
p3 = p3->next;
}
return l3->next;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
{
ListNode *retList = new ListNode(0);
auto tempList = retList;
int newVal;
int val1;
int val2;
int carryBit = 0;
while (l1 != nullptr || l2 != nullptr)
{
if (l1 == nullptr)
val1 = 0;
else
{
val1 = l1->val;
l1 = l1->next;
}
if (l2 == nullptr)
val2 = 0;
else
{
val2 = l2->val;
l2 = l2->next;
}
newVal = (val1 + val2 + carryBit) % 10;
carryBit = (val1 + val2 + carryBit) / 10;
tempList->next = new ListNode(newVal);
tempList = tempList->next;
}
if (carryBit == 1)
{
tempList->next = new ListNode(1);
}
return retList->next;
}
};
```
### B
```cpp
class Solution
{
public:
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
{
ListNode *l3 = new ListNode;
ListNode *l4 = l3;
int m = 0;
while (l1 != nullptr || l2 != nullptr)
{
if (l1 != nullptr && l2 != nullptr)
{
l3->val = (l1->val + l2->val + m) % 10;
m = (l1->val + l2->val + m) / 10;
l1 = l1->next;
l2 = l2->next;
}
else if (l1 != nullptr)
{
l3->val = (l1->val + m) % 10;
m = (l1->val + m) / 10;
l1 = l1->next;
}
else if (l2 != nullptr)
{
l3->val = (l2->val + m) % 10;
m = (l2->val + m) / 10;
l2 = l2->next;
}
if (l1 != nullptr || l2 != nullptr)
{
l3->next = new ListNode;
l3 = l3->next;
}
else
{
if (m > 0)
{
l3->next = new ListNode(m);
}
}
}
return l4;
}
};
```
### C
```cpp
class Solution
{
public:
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2)
{
ListNode *head = new ListNode(0), *r = head;
int up = 0;
while (l1 != NULL || l2 != NULL || up)
{
r->next = new ListNode(((l1 == NULL ? 0 : l1->val) + (l2 == NULL ? 0 : l2->val) + up) % 10);
up = ((l1 == NULL ? 0 : l1->val) + (l2 == NULL ? 0 : l2->val) + up) / 10;
r = r->next;
if (l1 != NULL)
l1 = l1->next;
if (l2 != NULL)
l2 = l2->next;
}
return head->next;
}
};
```
data/3.算法高阶/1.leetcode/20_合并两个有序链表/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 合并两个有序链表
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
int val;
struct ListNode *next;
ListNode() : val(0), next(nullptr){};
ListNode(int x) : val(x), next(nullptr){};
ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp
int main()
{
Solution sol;
ListNode *L1 = new ListNode;
ListNode *l11 = new ListNode(1);
ListNode *l12 = new ListNode(2);
ListNode *l13 = new ListNode(4);
L1->next = l11;
l11->next = l12;
l12->next = l13;
ListNode *L2 = new ListNode;
ListNode *l21 = new ListNode(1);
ListNode *l22 = new ListNode(3);
ListNode *l23 = new ListNode(4);
L2->next = l21;
l21->next = l22;
l22->next = l23;
ListNode *ret = new ListNode;
ret = sol.mergeTwoLists(L1, L2);
ListNode *p = ret->next;
while (p != NULL)
{
cout << p->val << " ";
p = p->next;
}
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
if (l1 == NULL)
return l2;
else if (l2 == NULL)
return l1;
else if (l1->val < l2->val)
{
l1->next = mergeTwoLists(l1->next, l2);
return l1;
}
else
{
l2->next = mergeTwoLists(l1, l2->next);
return l2;
}
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
l2 = l2->next;
ListNode *h = new ListNode(0);
ListNode *head = h;
while (l1 && l2)
{
if (l1->val < l2->val)
{
h->next = new ListNode(l1->val);
h = h->next;
l1 = l1->next;
}
else
{
h->next = new ListNode(l2->val);
h = h->next;
l2 = l2->next;
}
}
if (l1)
{
while (l1)
{
h->next = new ListNode(l1->val);
h = h->next;
l1 = l1->next;
}
}
else if (l2)
{
while (l2)
{
h->next = new ListNode(l2->val);
h = h->next;
l2 = l2->next;
}
}
ListNode *ptrDelete = head;
head = head->next;
delete ptrDelete;
return head;
}
};
```
### B
```cpp
class Solution
{
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
if (NULL == l1)
return l2;
if (NULL == l2)
return l1;
l1 = l1->next;
ListNode *p1 = l1;
ListNode *p2 = l2;
ListNode *head = new ListNode(-1);
ListNode *curNode = head;
while (NULL != p1 && NULL != p2)
{
if (p1->val < p2->val)
{
curNode->next = p1;
curNode = p1;
p1 = p1->next;
}
else
{
curNode->next = p2;
curNode = p2;
p2 = p2->next;
}
}
if (NULL != p1)
curNode->next = p1;
if (NULL != p2)
curNode->next = p2;
return head->next;
}
};
```
### C
```cpp
class Solution
{
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
vector<int> vec;
l1 = l1->next;
while (l1 != NULL)
{
vec.push_back(l1->val);
l1 = l1->next;
}
while (l2 != NULL)
{
vec.push_back(l2->val);
l2 = l2->next;
}
sort(vec.begin(), vec.end());
auto head = new ListNode;
auto cur = head;
for (const auto &c : vec)
{
auto p = new ListNode(c);
cur->next = p;
cur = p;
}
return head->next;
}
};
```
data/3.算法高阶/1.leetcode/21_括号生成/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 括号生成
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
int n = 3;
vector<string> res;
res = sol.generateParenthesis(n);
for (auto i : res)
cout << i << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
vector<string> generateParenthesis(int n)
{
vector<string> ans;
string s;
back(0, 2 * n, 0, 0, s, ans);
return ans;
}
void back(int left, int right, int l_n, int r_n, string &s, vector<string> &ans)
{
if (r_n > l_n || l_n > right)
return;
if (left == right)
{
ans.push_back(s);
return;
}
s += '(';
l_n++;
left++;
back(left, right, l_n, r_n, s, ans);
s.erase(s.end() - 1);
l_n--;
s += ')';
r_n++;
back(left, right, l_n, r_n, s, ans);
s.erase(s.end() - 1);
r_n--;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
void generateParenthesis(string i, int left, int right, vector<string> &output)
{
if (left == 0 && right == 0)
{
output.push_back(i);
return;
}
if (left > 0)
{
generateParenthesis(i + '(', left - 1, right, output);
}
if (left < right)
{
generateParenthesis(i + ')', left, right - 1, output);
}
}
vector<string> generateParenthesis(int n)
{
string s = "";
vector<string> output;
generateParenthesis(s, n, n, output);
return output;
}
};
```
### B
```cpp
class Solution
{
public:
vector<string> res;
void backtrack(int n, int key, string cur)
{
if (key < 0 || key > n)
return;
if (cur.size() == 2 * n)
{
if (key == 0)
res.push_back(cur);
return;
}
backtrack(n, key - 1, cur + ')');
backtrack(n, key + 1, cur + '(');
}
vector<string> generateParenthesis(int n)
{
if (n == 0)
return vector<string>{""};
string cur("(");
backtrack(n, 1, cur);
return res;
}
};
```
### C
```cpp
class Solution
{
public:
vector<string> generateParenthesis(int n)
{
vector<string> res;
dfs("", 0, n, &res);
return res;
}
void dfs(const string &path, int m, int n, vector<string> *res)
{
if (m == 0 && n == 0)
{
if (!path.empty())
res->push_back(path);
return;
}
if (n > 0)
dfs(path + '(', m + 1, n - 1, res);
if (m > 0)
dfs(path + ')', m - 1, n, res);
}
};
```
data/3.算法高阶/1.leetcode/22_合并K个升序链表/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 合并K个升序链表
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
int val;
struct ListNode *next;
ListNode() : val(0), next(nullptr){};
ListNode(int x) : val(x), next(nullptr){};
ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp
int main()
{
Solution sol;
ListNode *L1 = new ListNode;
ListNode *l11 = new ListNode(1);
ListNode *l12 = new ListNode(4);
ListNode *l13 = new ListNode(5);
L1->next = l11;
l11->next = l12;
l12->next = l13;
ListNode *L2 = new ListNode;
ListNode *l21 = new ListNode(1);
ListNode *l22 = new ListNode(3);
ListNode *l23 = new ListNode(4);
L2->next = l21;
l21->next = l22;
l22->next = l23;
ListNode *L3 = new ListNode;
ListNode *l31 = new ListNode(2);
ListNode *l32 = new ListNode(6);
L3->next = l31;
l31->next = l32;
ListNode *ret = new ListNode;
vector<ListNode *> lists = {L1, L2, L3};
ret = sol.mergeKLists(lists);
ListNode *p = ret->next;
while (p != NULL)
{
cout << p->val << " ";
p = p->next;
}
return 0;
}
```
## 答案
```cpp
struct cmp
{
bool operator()(ListNode *a, ListNode *b)
{
return a->val > b->val;
}
};
class Solution
{
public:
ListNode *mergeKLists(vector<ListNode *> &lists)
{
priority_queue<ListNode *, vector<ListNode *>, cmp> queue;
for (int i = 0; i < lists.size(); i++)
{
if (lists[i] != NULL)
queue.push(lists[i]);
}
if (queue.empty())
return NULL;
ListNode *root = new ListNode(-1);
ListNode *node;
ListNode *lastNode = root;
while (!queue.empty())
{
node = queue.top();
queue.pop();
lastNode->next = node;
lastNode = lastNode->next;
if (node->next)
queue.push(node->next);
}
lastNode->next = NULL;
return root->next;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
struct Status
{
int val;
ListNode *ptr;
bool operator<(const Status &rhs) const
{
return val > rhs.val;
}
};
priority_queue<Status> q;
ListNode *mergeKLists(vector<ListNode *> &lists)
{
for (int i = 0; i < lists.size() - 1; i++)
{
lists[i + 1] = lists[i + 1]->next;
}
for (auto node : lists)
{
if (node)
q.push({node->val, node});
}
ListNode head, *tail = &head;
while (!q.empty())
{
auto f = q.top();
q.pop();
tail->next = f.ptr;
tail = tail->next;
if (f.ptr->next)
q.push({f.ptr->next->val, f.ptr->next});
}
return head.next;
}
};
```
### B
```cpp
class Solution
{
public:
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
if (!l1 || !l2)
return l1 ? l1 : l2;
ListNode fake, *la = l1, *lb = l2;
ListNode *cur = &fake;
while (la && lb)
{
if (la->val < lb->val)
{
cur->next = la;
la = la->next;
}
else
{
cur->next = lb;
lb = lb->next;
}
cur = cur->next;
}
cur->next = la ? la : lb;
return fake.next;
}
ListNode *mergeKLists(vector<ListNode *> &lists)
{
ListNode *ans = nullptr;
for (size_t i = 0; i < lists.size(); ++i)
{
if (i >= 1)
lists[i] = lists[i]->next;
ans = mergeTwoLists(ans, lists[i]);
}
return ans;
}
};
```
### C
```cpp
class Solution
{
public:
ListNode *mergeTlists(ListNode *l1, ListNode *l2)
{
if (l1 == nullptr)
return l2;
else if (l2 == nullptr)
return l1;
else if (l1->val < l2->val)
{
l1->next = mergeTlists(l1->next, l2);
return l1;
}
else
{
l2->next = mergeTlists(l2->next, l1);
return l2;
}
}
ListNode *mergeKLists(vector<ListNode *> &lists)
{
int len = lists.size();
if (len == 0)
return nullptr;
if (len == 1)
return lists[0];
for (int i = 0; i < len - 1; i++)
{
lists[i + 1] = lists[i + 1]->next;
lists[i + 1] = mergeTlists(lists[i], lists[i + 1]);
}
return lists[len - 1];
}
};
```
data/3.算法高阶/1.leetcode/23_两两交换链表中的节点/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 两两交换链表中的节点
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
int val;
struct ListNode *next;
ListNode() : val(0), next(nullptr){};
ListNode(int x) : val(x), next(nullptr){};
ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp
```
## 答案
```cpp
class Solution
{
public:
ListNode *swapPairs(ListNode *head)
{
ListNode *new_head = new ListNode(0);
new_head->next = head;
ListNode *pre = new_head;
while (head && head->next)
{
ListNode *first = head;
ListNode *second = head->next;
pre->next = second;
first->next = first->next;
second->next = first;
pre = first;
head = first->next;
}
return new_head->next;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
ListNode *swapPairs(ListNode *head)
{
if (head == NULL || head->next == NULL)
return head;
ListNode *dummy = new ListNode(0);
dummy->next = head;
ListNode *p = dummy;
while (p->next != NULL && p->next->next != NULL)
{
ListNode *node1 = p->next;
ListNode *node2 = node1->next;
ListNode *next = node2->next;
node2->next = node1;
node1->next = next;
p->next = node2;
p = node1;
}
ListNode *retnode = dummy->next;
delete dummy;
return retnode;
}
};
```
### B
```cpp
class Solution {
public:
ListNode* swapPairs(ListNode* head) {
if (head == nullptr || head->next == nullptr) {
return head;
}
ListNode *next = head->next;
head->next = swapPairs(next->next);
next->next = head;
return next;
}
};
```
### C
```cpp
class Solution
{
public:
ListNode *swapPairs(ListNode *head)
{
ListNode *p = new ListNode(-1);
p->next = head;
ListNode *h = p;
while (p->next && p->next->next)
{
ListNode *c = p->next;
ListNode *n = p->next->next;
p->next = c->next;
c->next = n->next;
n->next = c;
p = c;
}
return h->next;
}
};
```
data/3.算法高阶/1.leetcode/24_K 个一组翻转链表/solution.md 0 → 100644
浏览文件 @ 46e221cd
# K 个一组翻转链表
以下错误的选项是？
## aop
### before
```cpp
struct ListNode
{
int val;
struct ListNode *next;
ListNode() : val(0), next(nullptr){};
ListNode(int x) : val(x), next(nullptr){};
ListNode(int x, ListNode *next) : val(x), next(next){};
};
```
### after
```cpp
```
## 答案
```cpp
class Solution
{
public:
ListNode *reverseKGroup(ListNode *head, int k)
{
if (head == NULL || head->next == NULL || k == 1)
return head;
ListNode *cur = head;
int i = 1;
while (cur->next != NULL)
{
cur = cur->next;
}
if (i < k)
return head;
stack<ListNode *> s;
ListNode *p = head;
while (s.size() != k)
{
s.push(p);
p = p->next;
}
ListNode *phead = s.top();
s.pop();
ListNode *p2 = phead;
while (!s.empty())
{
p2->next = s.top();
s.pop();
p2 = p2->next;
p2->next = NULL;
}
while (p != NULL)
{
s.push(p);
p = p->next;
if (s.size() == k)
{
while (!s.empty())
{
p2->next = s.top();
s.pop();
p2 = p2->next;
p2->next = NULL;
}
}
}
if (!s.empty())
{
stack<ListNode *> s2;
while (!s.empty())
{
s2.push(s.top());
s.pop();
}
while (!s2.empty())
{
p2->next = s2.top();
s2.pop();
p2 = p2->next;
}
}
return phead;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
vector<ListNode *> reverse(ListNode *head, int k)
{
ListNode *newhead = NULL;
vector<ListNode *> res;
res.push_back(head);
int i = 0;
ListNode *head1 = head;
while (head1)
{
i++;
head1 = head1->next;
if (i == k)
{
break;
}
}
if (i < k)
{
return res;
}
while (k)
{
ListNode *nexthead = head->next;
head->next = newhead;
newhead = head;
head = nexthead;
k--;
}
res.push_back(newhead);
res.push_back(head);
return res;
}
ListNode *reverseKGroup(ListNode *head, int k)
{
ListNode *newhead = new ListNode(0);
ListNode *tmp = newhead;
while (head)
{
vector<ListNode *> res = reverse(head, k);
if (res.size() == 3)
{
tmp->next = res[1];
tmp = res[0];
head = res[2];
}
else
{
tmp->next = res[0];
head = NULL;
}
}
return newhead->next;
}
};
```
### B
```cpp
class Solution
{
public:
ListNode *reverseK(ListNode *pre, ListNode *lat)
{
ListNode *lpre = pre->next;
ListNode *cur = lpre->next;
while (cur != lat)
{
lpre->next = cur->next;
cur->next = pre->next;
pre->next = cur;
cur = lpre->next;
}
return lpre;
}
ListNode *reverseKGroup(ListNode *head, int k)
{
ListNode *h = new ListNode(-1);
h->next = head;
ListNode *cur = head;
int t = 1;
ListNode *pre = h;
while (cur != NULL)
{
if (t % k == 0)
{
pre = reverseK(pre, cur->next);
cur = pre->next;
}
else
cur = cur->next;
t += 1;
}
return h->next;
}
};
```
### C
```cpp
class Solution
{
public:
ListNode *reverseKGroup(ListNode *head, int k)
{
int len = 0;
struct ListNode dummy, *prev = &dummy;
dummy.next = head;
for (; head != nullptr; head = head->next)
{
if (++len % k == 0)
{
struct ListNode *p = prev->next;
while (prev->next != head)
{
struct ListNode *q = p->next;
p->next = q->next;
q->next = prev->next;
prev->next = q;
}
prev = p;
head = p;
}
}
return dummy.next;
}
};
```
data/3.算法高阶/1.leetcode/25_删除有序数组中的重复项/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 删除有序数组中的重复项
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
int res;
int arr1[] = {1, 1, 2};
int length1 = sizeof(arr1) / sizeof(arr1[0]);
vector<int> nums1(arr1, arr1 + length1);
res = sol.removeDuplicates(nums1);
cout << res;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int removeDuplicates(vector<int> &nums)
{
if (nums.size() == 0)
return 0;
int i = 0;
for (int j = 1; j < nums.size(); j++)
{
if (nums[j] != nums[i])
{
i++;
nums[i] = nums[j];
}
}
return i;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int removeDuplicates(vector<int> &nums)
{
int len = 0;
int i = 0;
int j = 0;
for (i = 0, j = i + 1;; j++)
{
if (j >= nums.size())
{
break;
}
if (nums[i] != nums[j])
{
nums[i + 1] = nums[j];
i++;
}
}
len = nums.size() < i + 1 ? nums.size() : i + 1;
return len;
}
};
```
### B
```cpp
class Solution
{
public:
int removeDuplicates(vector<int> &nums)
{
int slow = 1, fast = 1;
if (nums.size() == 0)
return 0;
while (fast < nums.size())
{
if (nums[fast] != nums[fast - 1])
nums[slow++] = nums[fast++];
else
fast++;
}
return slow;
}
};
```
### C
```cpp
class Solution
{
public:
int removeDuplicates(vector<int> &nums)
{
if (nums.size() == 0)
{
return 0;
}
if (nums.size() == 1)
{
return 1;
}
vector<int>::iterator slow = nums.begin() + 1;
for (vector<int>::iterator fast = nums.begin() + 1; fast != nums.end(); fast++)
{
if (*fast != *(fast - 1))
{
*slow = *fast;
slow++;
}
}
nums.erase(slow, nums.end());
return nums.size();
}
};
```
data/3.算法高阶/1.leetcode/26_移除元素/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 移除元素
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/27_实现 strStr()/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 实现 strStr()
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/28_两数相除/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 两数相除
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/29_串联所有单词的子串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 串联所有单词的子串
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/2_无重复字符的最长子串/solution.cpp
浏览文件 @ 46e221cd
int hset[128]; class Solution
int lengthOfLongestSubstring(char *s)
{ {
int i = 0, j = 0; public:
int m = 0; int lengthOfLongestSubstring(String s)
memset(hset, 0, sizeof hset);
for (; s[j]; j++)
{ {
i = hset[s[j]] > i ? hset[s[j]] : i; int front = 0, rear = 0;
m = m > j - i + 1 ? m : j - i + 1; int temp = 0;
hset[s[j]] = j + 1; int lengthmax = 0;
for (rear = 0; rear < s.length(); rear++)
{
for (front = temp; front < rear; front++)
{
if (s.charAt(front) == s.charAt(rear))
{
temp = front + 1;
break;
}
}
if ((rear - temp + 1) > lengthmax)
{
lengthmax = (rear - temp + 1);
}
}
return lengthmax;
} }
return m;
} }
data/3.算法高阶/1.leetcode/2_无重复字符的最长子串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 无重复字符的最长子串
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution test;
int ret;
string s = "bbbbb";
ret = test.lengthOfLongestSubstring(s);
cout << ret;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
int count = 0;
int i = 0, j = 1, p1 = 0, p2 = 0;
if (s.length() == 0)
return 0;
else
{
count = 1;
while (s[j] != '\0')
{
for (int i = p1; i <= p2; i++)
{
if (s[i] == s[j])
{
p1 = i + 1;
break;
}
}
p2 = j;
count = count >= (p2 - p1 + 1) ? (p2 - p1 + 1) : count;
j++;
}
}
return count;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
map<char, int> hash;
int ans = 0;
int n = s.size();
for (int i = 0, j = 0; j < n; j++)
{
if (hash.find(s[j]) != hash.end())
i = max(hash.find(s[j])->second + 1, i);
ans = max(ans, j - i + 1);
hash[s[j]] = j;
}
return ans;
}
};
```
### B
```cpp
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
map<char, int> hash;
int ans = 0;
int i = 0;
int j = 0;
int n = s.length();
while (i < n && j < n)
{
if (hash.find(s[j]) == hash.end())
{
hash[s[j++]] = j;
ans = max(ans, j - i);
}
else
hash.erase(s[i++]);
}
return ans;
}
};
```
### C
```cpp
class Solution
{
public:
int lengthOfLongestSubstring(string s)
{
int ans = 0;
for (int i = 0; i < s.size(); i++)
for (int j = i + 1; j <= s.size(); j++)
{
if (allUnique(s, i, j))
ans = max(ans, j - i);
}
return ans;
}
bool allUnique(string s, int begin, int end)
{
map<char, int> hash;
for (int i = begin; i < end; i++)
{
if (hash.find(s[i]) != hash.end())
return false;
hash[s[i]] = i;
}
return true;
}
};
```
data/3.算法高阶/1.leetcode/30_下一个排列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 下一个排列
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/31_最长有效括号/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最长有效括号
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/32_搜索旋转排序数组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 搜索旋转排序数组
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/33_在排序数组中查找元素的第一个和最后一个位置/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 在排序数组中查找元素的第一个和最后一个位置
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/34_搜索插入位置/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 搜索插入位置
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/35_有效的数独/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 有效的数独
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/36_解数独/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 解数独
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/37_外观数列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 外观数列
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/38_组合总和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 组合总和
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/39_组合总和 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 组合总和 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/3_寻找两个正序数组的中位数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 寻找两个正序数组的中位数
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution test;
float ret;
int arr1[] = {1, 2};
int arr2[] = {3, 4};
int length1 = sizeof(arr1) / sizeof(arr1[0]);
int length2 = sizeof(arr2) / sizeof(arr2[0]);
vector<int> nums1(arr1, arr1 + length1);
vector<int> nums2(arr2, arr2 + length2);
ret = test.findMedianSortedArrays(nums1, nums2);
cout << setiosflags(ios::fixed) << setprecision(5) << ret << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int getK(vector<int> nums1, vector<int> nums2, int k)
{
int len1 = nums1.size();
int len2 = nums2.size();
int index1 = 0, index2 = 0;
while (1)
{
if (index1 == len1)
{
return nums2[index2 + k - 1];
}
if (index2 == len2)
{
return nums1[index1 + k - 1];
}
if (k == 1)
{
return max(nums1[index1], nums2[index2]);
}
int newIndex1 = max(index1 + k / 2 - 1, len1 - 1);
int newIndex2 = max(index2 + k / 2 - 1, len2 - 1);
if (nums1[newIndex1] <= nums2[newIndex2])
{
k -= newIndex1 - index1 + 1;
index1 = newIndex1 + 1;
}
else
{
k -= newIndex2 - index2 + 1;
index2 = newIndex2 + 1;
}
}
}
double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2)
{
int wholeLen = nums1.size() + nums2.size();
if (wholeLen % 2 == 0)
{
return (getK(nums1, nums2, wholeLen / 2) + getK(nums1, nums2, wholeLen / 2 + 1)) / 2.0;
}
else
{
return getK(nums1, nums2, wholeLen / 2 + 1);
}
}
};
```
## 选项
### A
```cpp
class Solution
{
int len1;
int len2;
public:
double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2)
{
if (nums1.size() <= 0 && nums2.size() <= 0)
return 0;
len1 = nums1.size();
len2 = nums2.size();
int left = (len1 + len2 + 1) / 2, right = (len1 + len2 + 2) / 2;
return (find(nums1, 0, nums2, 0, left) + find(nums1, 0, nums2, 0, right)) / 2.0;
}
int find(vector<int> &nums1, int i, vector<int> &nums2, int j, int k)
{
if (i >= nums1.size())
return nums2[j + k - 1];
if (j >= nums2.size())
return nums1[i + k - 1];
if (k == 1)
return min(nums1[i], nums2[j]);
int midval1 = i + k / 2 - 1 < nums1.size() ? nums1[i + k / 2 - 1] : INT_MAX;
int midval2 = j + k / 2 - 1 < nums2.size() ? nums2[j + k / 2 - 1] : INT_MAX;
if (midval1 < midval2)
return find(nums1, i + k / 2, nums2, j, k - k / 2);
else
return find(nums1, i, nums2, j + k / 2, k - k / 2);
}
};
```
### B
```cpp
class Solution
{
public:
double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2)
{
vector<int> vecSumArr(nums1.size() + nums2.size());
merge(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), vecSumArr.begin());
if (vecSumArr.size() % 2 == 0)
return (*(vecSumArr.begin() + vecSumArr.size() / 2 - 1) + *(vecSumArr.begin() + vecSumArr.size() / 2)) * 1.0 / 2;
else
return *(vecSumArr.begin() + vecSumArr.size() / 2);
}
};
```
### C
```cpp
class Solution
{
public:
double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2)
{
int nums1Size = nums1.size();
int nums2Size = nums2.size();
int na = nums1Size + nums2Size;
int *ns = (int *)malloc(4 * na);
int i = 0, j = 0, d = 0;
int m = na / 2 + 1;
while (d < m)
{
int n;
if (i < nums1Size && j < nums2Size)
{
n = (nums1[i] < nums2[j]) ? nums1[i++] : nums2[j++];
}
else if (i < nums1Size)
{
n = nums1[i++];
}
else if (j < nums2Size)
{
n = nums2[j++];
}
ns[d++] = n;
}
if (na % 2)
{
return ns[d - 1];
}
return (ns[d - 1] + ns[d - 2]) / 2.0;
}
};
```
data/3.算法高阶/1.leetcode/40_缺失的第一个正数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 缺失的第一个正数
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/41_接雨水/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 接雨水
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/42_字符串相乘/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字符串相乘
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/43_通配符匹配/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 通配符匹配
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/44_跳跃游戏 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 跳跃游戏 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/45_全排列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 全排列
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/46_全排列 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 全排列 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/47_旋转图像/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 旋转图像
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/48_字母异位词分组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字母异位词分组
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/49_Pow(x, n)/solution.md 0 → 100644
浏览文件 @ 46e221cd
# Pow(x, n)
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/4_最长回文子串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最长回文子串
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution test;
string ret;
string s = "cbbd";
ret = test.longestPalindrome(s);
cout << ret << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
string longestPalindrome(string s)
{
int len = s.size();
if (len == 0 || len == 1)
return s;
int start = 0;
int end = 0;
int mlen = 0;
for (int i = 0; i < len; i++)
{
int len1 = expendaroundcenter(s, i, i);
int len2 = expendaroundcenter(s, i, i + 1);
mlen = max(min(len1, len2), mlen);
if (mlen > end - start + 1)
{
start = i - (mlen - 1) / 2;
end = i + mlen / 2;
}
}
return s.substr(start, mlen);
}
private:
int expendaroundcenter(string s, int left, int right)
{
int L = left;
int R = right;
while (L >= 0 && R < s.length() && s[R] == s[L])
{
L--;
R++;
}
return R - L - 1;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
string longestPalindrome(string s)
{
int len = s.size();
if (len == 0 || len == 1)
return s;
int start = 0;
int max = 1;
vector<vector<int>> dp(len, vector<int>(len));
for (int i = 0; i < len; i++)
{
dp[i][i] = 1;
if (i < len - 1 && s[i] == s[i + 1])
{
dp[i][i + 1] = 1;
max = 2;
start = i;
}
}
for (int l = 3; l <= len; l++)
{
for (int i = 0; i + l - 1 < len; i++)
{
int j = l + i - 1;
if (s[i] == s[j] && dp[i + 1][j - 1] == 1)
{
dp[i][j] = 1;
start = i;
max = l;
}
}
}
return s.substr(start, max);
}
};
```
### B
```cpp
class Solution
{
public:
string longestPalindrome(string s)
{
if (s.length() == 1)
return s;
string rev = s;
string res;
std::reverse(rev.begin(), rev.end());
if (rev == s)
return s;
int len = 0;
for (int i = 0; i < s.length(); i++)
{
string temp;
for (int j = i; j < s.length(); j++)
{
temp = temp + s[j];
if (len >= temp.length())
continue;
else if (rev.find(temp) != -1)
{
string q = temp;
std::reverse(q.begin(), q.end());
if (q == temp)
{
len = temp.length();
res = temp;
}
}
else
break;
}
temp = "";
}
return res;
}
};
```
### C
```cpp
class Solution
{
public:
string longestPalindrome(string s)
{
string res = "";
string temp = "";
for (int i = 0; i < s.length(); i++)
{
for (int j = i; j < s.length(); j++)
{
temp = temp + s[j];
string tem = temp;
std::reverse(tem.begin(), tem.end());
if (temp == tem)
res = res.length() > temp.length() ? res : temp;
}
temp = "";
}
return res;
}
};
```
data/3.算法高阶/1.leetcode/50_N 皇后/solution.md 0 → 100644
浏览文件 @ 46e221cd
# N 皇后
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/51_N皇后 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# N皇后 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/52_最大子序和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最大子序和
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/53_螺旋矩阵/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 螺旋矩阵
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/54_跳跃游戏/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 跳跃游戏
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/55_合并区间/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 合并区间
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/56_插入区间/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 插入区间
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/57_最后一个单词的长度/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最后一个单词的长度
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/58_螺旋矩阵 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 螺旋矩阵 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/59_排列序列/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 排列序列
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/5_Z 字形变换/solution.md 0 → 100644
浏览文件 @ 46e221cd
# Z 字形变换
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution test;
string ret;
string s = "LEETCODEISHIRING";
int numrows = 3;
ret = test.convert(s, numrows);
cout << ret << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
string convert(string s, int numRows)
{
string result;
int num1 = numRows * 2 - 2;
if (s.size() < 2 || num1 == 0)
{
result = s;
return result;
}
int num = (s.size() / num1);
string str[100];
int count = 0;
int i = 0;
for (int j = 0; j < s.size(); j++)
{
if (count == num1)
{
i++;
count = 0;
}
str[i].push_back(s[j]);
}
for (int n = 0; n < num; n++)
{
result.push_back(str[n][0]);
}
for (int m = 1; m < numRows; m++)
{
for (int n = 0; n < num; n++)
{
if (m < str[n].size())
result.push_back(str[n][m]);
if ((num1 - m) < str[n].size() && m != (num1 - m))
result.push_back(str[n][num1 - m]);
}
}
return result;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
string convert(string s, int numRows)
{
string result;
int i = 0;
int j = 0;
int tem = numRows != 1 ? 2 * (numRows - 1) : 1;
for (i = 0; i <= tem / 2; ++i)
{
j = i;
while (j < s.size())
{
result += s[j];
if (j % tem != 0 && j % tem != tem / 2 && j + tem - 2 * i < s.size())
{
result += s[j + tem - 2 * i];
}
j += tem;
}
}
return result;
}
};
```
### B
```cpp
class Solution
{
public:
string convert(string s, int numRows)
{
if (numRows == 1 || s.size() <= numRows)
return s;
vector<string> rows(numRows);
int curRow = 0;
bool goingDown = false;
for (char c : s)
{
rows[curRow] += c;
if (curRow == 0 || curRow == numRows - 1)
goingDown = !goingDown;
curRow += goingDown ? 1 : -1;
}
string ret;
for (string row : rows)
ret += row;
return ret;
}
};
```
### C
```cpp
class Solution
{
public:
string convert(string s, int numRows)
{
if (s.size() <= numRows || numRows <= 1)
return s;
int len = s.size();
vector<vector<char> > pos(len, vector<char>(numRows));
int k = 0;
int flag = numRows - 1;
for (int i = 0; i < len; i++)
{
for (int j = 0; j < numRows; j++)
{
if (i % (numRows - 1) == 0 || numRows == 2)
{
pos[i][j] = s[k];
k++;
}
else if (j == flag - 1)
{
pos[i][j] = s[k];
k++;
flag--;
}
else
continue;
if (k == len)
break;
}
if (k == len)
break;
if (flag == 1)
flag = numRows - 1;
}
string res;
for (int j = 0; j <= numRows; j++)
{
int count = 0;
for (int i = 0; i < len; i++)
{
if (j % (numRows - 1) == 0 && pos[i][j] != '\0')
{
res = res + pos[i][j];
i = i + numRows - 2;
count = 0;
continue;
}
else if (j % (numRows - 1) != 0 && pos[i][j] != '\0')
{
res = res + pos[i][j];
count = 0;
continue;
}
else
count++;
if (count >= numRows)
break;
}
if (res.size() == len)
break;
}
return res;
}
};
```
data/3.算法高阶/1.leetcode/60_旋转链表/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 旋转链表
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/61_不同路径/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 不同路径
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/62_不同路径 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 不同路径 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/63_最小路径和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最小路径和
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/64_有效数字/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 有效数字
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/65_加一/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 加一
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/66_二进制求和/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 二进制求和
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/67_文本左右对齐/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 文本左右对齐
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/68_x 的平方根/solution.md 0 → 100644
浏览文件 @ 46e221cd
# x 的平方根
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/69_爬楼梯/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 爬楼梯
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/6_整数反转/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 整数反转
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution test;
int ret;
int x = -123;
int numrows = 3;
ret = test.reverse(x);
cout << ret << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int reverse(int x)
{
long n = 0;
while (x)
{
n = x % 10 + n * 10;
x /= 10;
}
return n > INT_MAX || n < INT_MIN ? n : 0;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int reverse(int x)
{
int MAX = 0x7fffffff;
int MIN = 1 << 31;
ostringstream stream, smax, smin;
string ss;
stream << x;
ss += stream.str();
smax << MAX;
string max_num = smax.str();
smin << MIN;
string min_num = smin.str();
std::reverse(ss.begin(), ss.end());
if (x < 0)
{
ss.insert(0, "-");
ss.pop_back();
}
if (x > 0 && ss.size() >= max_num.size() && (ss > max_num))
return 0;
else if (x < 0 && ss.size() >= min_num.size() && ss > min_num)
return 0;
else
return atoi(ss.c_str());
}
};
```
### B
```cpp
class Solution
{
public:
#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX - 1)
int reverse(int x)
{
int flag = x < 0 ? -1 : 1;
int num = 0;
while (x)
{
if ((flag == -1 && (INT_MIN / 10 > num)) || (flag == 1 && INT_MAX / 10 < num))
return 0;
num = num * 10 + x % 10;
x /= 10;
}
return num;
}
};
```
### C
```cpp
class Solution
{
public:
int reverse(int x)
{
int rev = 0;
while (x != 0)
{
int pop = x % 10;
x = x / 10;
if (rev > INT_MAX / 10 || (rev == INT_MAX / 10 && pop > 7))
return 0;
if (rev < INT_MIN / 10 || (rev == INT_MIN / 10 && pop < -8))
return 0;
rev = rev * 10 + pop;
}
return rev;
}
};
```
data/3.算法高阶/1.leetcode/70_简化路径/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 简化路径
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/71_编辑距离/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 编辑距离
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/72_矩阵置零/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 矩阵置零
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/73_搜索二维矩阵/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 搜索二维矩阵
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/74_颜色分类/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 颜色分类
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/75_最小覆盖子串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最小覆盖子串
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/76_组合/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 组合
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/77_子集/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 子集
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/78_单词搜索/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 单词搜索
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/79_删除有序数组中的重复项 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 删除有序数组中的重复项 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/7_字符串转换整数 (atoi)/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 字符串转换整数 (atoi)
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
cout << sol.myAtoi("-42") << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
int myAtoi(string s)
{
int index = 0;
while (index < s.length() && s[index] == ' ')
index++;
int sign = 1;
if (index < s.length() && (s[index] == '+' || s[index] == '-'))
{
if (s[index] == '-')
sign = -1;
index++;
}
int val = 0;
while (index < s.length() && (s[index] >= '0' && s[index] <= '9'))
{
if (val > (2147483647 - (s[index] - '0')) / 10)
{
if (sign == -1)
return -2147483648;
else
return 2147483647;
}
val = val * 10 + (s[index] - '0');
index++;
}
return val;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
int myAtoi(string str)
{
int d = 0;
istringstream is(str);
is >> d;
return d;
}
};
```
### B
```cpp
class Solution
{
public:
int myAtoi(string str)
{
int i = 0;
while (' ' == str[i])
++i;
long flag = 1;
if ('+' == str[i])
{
flag = 1;
return fun(str, ++i, flag);
}
else if ('-' == str[i])
{
flag = -1;
return fun(str, ++i, flag);
}
else if (str[i] - '0' >= 0 && str[i] - '0' <= 9)
{
flag = 1;
return fun(str, i, flag);
}
else
{
return 0;
}
}
int fun(string str, int i, const long flag)
{
long res = 0;
while (str[i] - '0' >= 0 && str[i] - '0' <= 9)
{
res = res * 10 + (str[i++] - '0');
if (res * flag > pow(2, 31) - 1)
return INT_MAX;
if (res * flag < -pow(2, 31))
return INT_MIN;
}
res = res * flag;
return int(res);
}
};
```
### C
```cpp
class Solution
{
public:
int myAtoi(string str)
{
int max = INT_MAX / 10;
int min = INT_MIN / 10;
int max_f = INT_MAX % 10;
int min_f = INT_MIN % 10;
int len = str.length();
bool flag = false;
int sum = 0;
int symbol = 1;
for (int i = 0; i < len; i++)
{
char ch = str[i];
if (!flag)
{
if (ch == ' ')
continue;
else if (ch == '+')
flag = true;
else if (ch == '-')
{
flag = true;
symbol = -1;
}
else if (ch <= '9' && ch >= '0')
flag = true;
else
break;
}
else if (ch > '9' || ch < '0')
break;
if (ch <= '9' && ch >= '0')
{
int pos = symbol * (ch - '0');
if (sum > max || (sum == max && pos >= max_f))
return INT_MAX;
if (sum < min || (sum == min && pos <= min_f))
return INT_MIN;
sum = sum * 10 + pos;
}
}
return sum;
}
};
```
data/3.算法高阶/1.leetcode/80_搜索旋转排序数组 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 搜索旋转排序数组 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/81_删除排序链表中的重复元素 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 删除排序链表中的重复元素 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/82_删除排序链表中的重复元素/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 删除排序链表中的重复元素
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/83_柱状图中最大的矩形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 柱状图中最大的矩形
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/84_最大矩形/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 最大矩形
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/85_分隔链表/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 分隔链表
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/86_扰乱字符串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 扰乱字符串
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/87_合并两个有序数组/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 合并两个有序数组
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/88_格雷编码/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 格雷编码
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/89_子集 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 子集 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/8_回文数/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 回文数
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
cout << sol.isPalindrome(1121) << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
bool isPalindrome(int x)
{
string s = to_string(x);
for (int i = 0; i < s.length(); ++i)
{
if (s[i] != s[s.length() - i])
return false;
}
return true;
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
bool isPalindrome(int x)
{
if (x < 0)
return false;
double sum;
int m = x;
while (x)
{
sum = sum * 10 + x % 10;
x = x / 10;
}
if (m == sum)
return true;
else
return false;
}
};
```
### B
```cpp
class Solution
{
public:
bool isPalindrome(int x)
{
int midrev = 0;
if (x < 0 || (x % 10 == 0 && x != 0))
return false;
while (x > midrev)
{
midrev = midrev * 10 + x % 10;
x /= 10;
}
return midrev == x || midrev / 10 == x;
}
};
```
### C
```cpp
class Solution
{
public:
bool isPalindrome(int x)
{
long rev;
if (x < 0)
return false;
string str_x = to_string(x);
std::reverse(str_x.begin(), str_x.end());
stringstream out(str_x);
out >> rev;
return x == rev;
}
};
```
data/3.算法高阶/1.leetcode/90_解码方法/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 解码方法
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/91_反转链表 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 反转链表 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/92_复原 IP 地址/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 复原 IP 地址
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/93_二叉树的中序遍历/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 二叉树的中序遍历
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/94_不同的二叉搜索树 II/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 不同的二叉搜索树 II
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/95_不同的二叉搜索树/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 不同的二叉搜索树
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/96_交错字符串/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 交错字符串
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/97_验证二叉搜索树/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 验证二叉搜索树
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/98_恢复二叉搜索树/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 恢复二叉搜索树
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/99_相同的树/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 相同的树
以下错误的选项是？
## aop
### before
```cpp
```
### after
```cpp
```
## 答案
```cpp
```
## 选项
### A
```cpp
```
### B
```cpp
```
### C
```cpp
```
data/3.算法高阶/1.leetcode/9_正则表达式匹配/solution.md 0 → 100644
浏览文件 @ 46e221cd
# 正则表达式匹配
以下错误的选项是？
## aop
### before
```cpp
#include <bits/stdc++.h>
using namespace std;
```
### after
```cpp
int main()
{
Solution sol;
string s = "aa";
string p = "a";
cout << sol.isMatch(s, p) << endl;
return 0;
}
```
## 答案
```cpp
class Solution
{
public:
bool isMatch(string s, string p)
{
return match(s, p, s.length() - 1, p.length() - 1);
}
bool match(const string &s, const string &p, int rs, int rp)
{
if (rp == -1 && rs == -1)
{
return true;
}
if (rs < -1 || rp <= -1)
return false;
if (p[rp] == '.')
{
return match(s, p, rs - 1, rp - 1);
}
else if (p[rp] == '*')
{
if (p[rp - 1] != s[rs] && p[rp - 1] != '.')
{
return match(s, p, rs, rp - 2);
}
else
{
return match(s, p, rs, rp - 2);
}
}
else
{
if (p[rp] != s[rs])
{
return false;
}
else
{
return match(s, p, rs - 1, rp - 1);
}
}
}
};
```
## 选项
### A
```cpp
class Solution
{
public:
bool isMatch(string s, string p)
{
int lens = s.length(), lenp = p.length();
if (lenp == 0)
return lens == 0;
if (lenp == 1)
{
if (lens == 0)
return false;
if (lens != 0 && (p[0] == s[0] || p[0] == '.'))
return isMatch(s.substr(1), p.substr(1));
else
return false;
}
if (lenp >= 2)
{
if (p[1] != '*')
{
if (s.length() != 0 && (p[0] == s[0] || p[0] == '.'))
return isMatch(s.substr(1), p.substr(1));
else
return false;
}
else
{
while (s.length() != 0 && (p[0] == s[0] || p[0] == '.'))
{
if (isMatch(s, p.substr(2)))
return true;
else
{
s = s.substr(1);
}
}
return isMatch(s, p.substr(2));
}
}
}
};
```
### B
```cpp
class Solution
{
public:
bool first_match(string s, string p, int i, int j)
{
return s[i] == p[j] || p[j] == '.';
}
bool isMatch(string s, string p)
{
vector<vector<bool> > dp(s.size() + 1, vector<bool>(p.size() + 1));
dp[0][0] = true;
for (int j = 2; j <= p.size(); j++)
{
dp[0][j] = p[j - 1] == '*' && dp[0][j - 2];
}
for (int i = 0; i < s.size(); i++)
{
for (int j = 0; j < p.size(); j++)
{
if (p[j] == '*')
{
dp[i + 1][j + 1] = dp[i + 1][j - 1] || first_match(s, p, i, j - 1) && dp[i][j + 1];
}
else
{
dp[i + 1][j + 1] = first_match(s, p, i, j) && dp[i][j];
}
}
}
return dp[s.size()][p.size()];
}
};
```
### C
```cpp
class Solution
{
public:
bool isMatch(string s, string p)
{
if (p.empty())
return s.empty();
bool first = !s.empty() && (p[0] == '.' || s[0] == p[0]);
if (p[1] == '*')
return first && isMatch(s.substr(1), p) || isMatch(s, p.substr(2));
else
return first && isMatch(s.substr(1), p.substr(1));
}
};
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或