update desc

data_backup/1.leetcode/1-两数之和/solution.md

 # 两数之和
+
 <p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值</strong> 的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p><p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p><p>你可以按任意顺序返回答案。</p><p> </p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>nums = [2,7,11,15], target = 9<strong><br />输出：</strong>[0,1]<strong><br />解释：</strong>因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。</pre><p><strong>示例 2：</strong></p><pre><strong>输入：</strong>nums = [3,2,4], target = 6<strong><br />输出：</strong>[1,2]</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>nums = [3,3], target = 6<strong><br />输出：</strong>[0,1]</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>2 <= nums.length <= 10<sup>3</sup></code></li>	<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>	<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>	<li><strong>只会存在一个有效答案</strong></li></ul>
 <p>以下错误的选项是？</p>
+
 ## aop
 ### before
 ```cpp

data_backup/1.leetcode/10-正则表达式匹配/solution.md

 # 正则表达式匹配
+
 <p>给你一个字符串 <code>s</code> 和一个字符规律 <code>p</code>，请你来实现一个支持 <code>'.'</code> 和 <code>'*'</code> 的正则表达式匹配。</p><ul>	<li><code>'.'</code> 匹配任意单个字符</li>	<li><code>'*'</code> 匹配零个或多个前面的那一个元素</li></ul><p>所谓匹配，是要涵盖 <strong>整个 </strong>字符串 <code>s</code>的，而不是部分字符串。</p><p><strong>示例 1：</strong></p><pre><strong>输入：</strong>s = "aa" p = "a"<strong><br />输出：</strong>false<strong><br />解释：</strong>"a" 无法匹配 "aa" 整个字符串。</pre><p><strong>示例 2:</strong></p><pre><strong>输入：</strong>s = "aa" p = "a*"<strong><br />输出：</strong>true<strong><br />解释：</strong>因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。</pre><p><strong>示例 3：</strong></p><pre><strong>输入：</strong>s = "ab" p = ".*"<strong><br />输出：</strong>true<strong><br />解释：</strong>".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。</pre><p><strong>示例 4：</strong></p><pre><strong>输入：</strong>s = "aab" p = "c*a*b"<strong><br />输出：</strong>true<strong><br />解释：</strong>因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。</pre><p><strong>示例 5：</strong></p><pre><strong>输入：</strong>s = "mississippi" p = "mis*is*p*."<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul>	<li><code>0 <= s.length <= 20</code></li>	<li><code>0 <= p.length <= 30</code></li>	<li><code>s</code> 可能为空，且只包含从 <code>a-z</code> 的小写字母。</li>	<li><code>p</code> 可能为空，且只包含从 <code>a-z</code> 的小写字母，以及字符 <code>.</code> 和 <code>*</code>。</li>	<li>保证每次出现字符 <code>*</code> 时，前面都匹配到有效的字符</li></ul>
 <p>以下错误的选项是？</p>
+
 ## aop
 ### before
 ```cpp

data_backup/1.leetcode/100-相同的树/solution.md

 # 相同的树
+
 <p>给你两棵二叉树的根节点 <code>p</code> 和 <code>q</code> ，编写一个函数来检验这两棵树是否相同。</p><p>如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。</p><p> </p><p><strong>示例 1：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex1.jpg" style="width: 622px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2,3], q = [1,2,3]<strong><br />输出：</strong>true</pre><p><strong>示例 2：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex2.jpg" style="width: 382px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2], q = [1,null,2]<strong><br />输出：</strong>false</pre><p><strong>示例 3：</strong></p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0100-0199/0100.Same%20Tree/images/ex3.jpg" style="width: 622px; height: 182px;" /><pre><strong>输入：</strong>p = [1,2,1], q = [1,1,2]<strong><br />输出：</strong>false</pre><p> </p><p><strong>提示：</strong></p><ul>	<li>两棵树上的节点数目都在范围 <code>[0, 100]</code> 内</li>	<li><code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code></li></ul>
 <p>以下错误的选项是？</p>
+
 ## aop
 ### before
 ```cpp

data_backup/1.leetcode/1000-合并石头的最低成本/solution.md

+# 两数之和
+
+<p>有 <code>N</code> 堆石头排成一排，第 <code>i</code> 堆中有&nbsp;<code>stones[i]</code>&nbsp;块石头。</p>
+
+<p>每次<em>移动（move）</em>需要将<strong>连续的</strong>&nbsp;<code>K</code>&nbsp;堆石头合并为一堆，而这个移动的成本为这&nbsp;<code>K</code>&nbsp;堆石头的总数。</p>
+
+<p>找出把所有石头合并成一堆的最低成本。如果不可能，返回 <code>-1</code> 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>stones = [3,2,4,1], K = 2
+<strong>输出：</strong>20
+<strong>解释：</strong>
+从 [3, 2, 4, 1] 开始。
+合并 [3, 2]，成本为 5，剩下 [5, 4, 1]。
+合并 [4, 1]，成本为 5，剩下 [5, 5]。
+合并 [5, 5]，成本为 10，剩下 [10]。
+总成本 20，这是可能的最小值。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>stones = [3,2,4,1], K = 3
+<strong>输出：</strong>-1
+<strong>解释：</strong>任何合并操作后，都会剩下 2 堆，我们无法再进行合并。所以这项任务是不可能完成的。.
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>stones = [3,5,1,2,6], K = 3
+<strong>输出：</strong>25
+<strong>解释：</strong>
+从 [3, 5, 1, 2, 6] 开始。
+合并 [5, 1, 2]，成本为 8，剩下 [3, 8, 6]。
+合并 [3, 8, 6]，成本为 17，剩下 [17]。
+总成本 25，这是可能的最小值。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= stones.length &lt;= 30</code></li>
+	<li><code>2 &lt;= K &lt;= 30</code></li>
+	<li><code>1 &lt;= stones[i] &lt;= 100</code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1001-网格照明/solution.md

+# 两数之和
+
+<p>在 <code>N x N</code> 的网格 <code>grid</code> 上，每个单元格都有一盏灯，最初灯都处于 <strong>关闭</strong> 状态。</p>
+
+<p>数组 <code>lamps</code> 表示打开的灯的位置。<code>lamps[i] = [row<sub>i</sub>, col<sub>i</sub>]</code> 表示 <strong>打开</strong> 位于 <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code> 的第 <code>i</code> 盏灯 。每盏灯都照亮自身单元格以及同一行、同一列和两条对角线上的所有其他单元格。</p>
+
+<p>查询数组 <code>queries</code> 中，第 <code>i</code> 次查询 <code>queries[i] = [row<sub>i</sub>, col<sub>i</sub>]</code>，如果单元格 <code>[row<sub>i</sub>, col<sub>i</sub>]</code> 是被照亮的，则查询结果为 <code>1</code> ，否则为 <code>0</code> 。在第 <code>i</code> 次查询之后 [按照查询的顺序] ，<strong>关闭</strong> 位于单元格 <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code> 上或其相邻 8 个方向上（与单元格 <code>grid[row<sub>i</sub>][col<sub>i</sub>]</code> 共享角或边）的任何灯。</p>
+
+<p>返回答案数组 <code>ans</code> ， <code>answer[i]</code> 应等于第 <code>i</code> 次查询 <code>queries[i]</code> 的结果，<code>1</code> 表示照亮，<code>0</code> 表示未照亮。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/19/illu_1.jpg" style="width: 750px; height: 209px;" />
+<pre>
+<strong>输入：</strong>N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
+<strong>输出：</strong>[1,0]
+<strong>解释：</strong>最初所有灯都是关闭的。在执行查询之前，打开位于 [0, 0] 和 [4, 4] 的灯。第 0 次查询检查 grid[1][1] 是否被照亮（蓝色方框）。该单元格被照亮，所以 ans[0] = 1 。然后，关闭红色方框中的所有灯。
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/19/illu_step1.jpg" style="width: 500px; height: 218px;" />
+第 1 次查询检查 grid[1][0] 是否被照亮（蓝色方框）。该单元格没有被照亮，所以 ans[1] = 0 。然后，关闭红色矩形中的所有灯。
+<img alt="" src="https://assets.leetcode.com/uploads/2020/08/19/illu_step2.jpg" style="width: 500px; height: 219px;" />
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,1]]
+<strong>输出：</strong>[1,1]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>N = 5, lamps = [[0,0],[0,4]], queries = [[0,4],[0,1],[1,4]]
+<strong>输出：</strong>[1,1,0]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= N <= 10<sup>9</sup></code></li>
+	<li><code>0 <= lamps.length <= 20000</code></li>
+	<li><code>lamps[i].length == 2</code></li>
+	<li><code>0 <= lamps[i][j] < N</code></li>
+	<li><code>0 <= queries.length <= 20000</code></li>
+	<li><code>queries[i].length == 2</code></li>
+	<li><code>0 <= queries[i][j] < N</code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1002-查找常用字符/solution.md

+# 两数之和
+
+给你一个字符串数组 <code>words</code> ，请你找出所有在 <code>words</code> 的每个字符串中都出现的共用字符（ <strong>包括重复字符</strong>），并以数组形式返回。你可以按 <strong>任意顺序</strong> 返回答案。
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>words = ["bella","label","roller"]
+<strong>输出：</strong>["e","l","l"]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>words = ["cool","lock","cook"]
+<strong>输出：</strong>["c","o"]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 100</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 100</code></li>
+	<li><code>words[i]</code> 由小写英文字母组成</li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1003-检查替换后的词是否有效/solution.md

+# 两数之和
+
+给你一个字符串 <code>s</code> ，请你判断它是否 <strong>有效</strong> 。
+<p>字符串 <code>s</code> <strong>有效</strong> 需要满足：假设开始有一个空字符串 <code>t = ""</code> ，你可以执行 <strong>任意次</strong> 下述操作将<strong> </strong><code>t</code><strong> 转换为 </strong><code>s</code> ：</p>
+
+<ul>
+	<li>将字符串 <code>"abc"</code> 插入到 <code>t</code> 中的任意位置。形式上，<code>t</code> 变为 <code>t<sub>left</sub> + "abc" + t<sub>right</sub></code>，其中 <code>t == t<sub>left</sub> + t<sub>right</sub></code> 。注意，<code>t<sub>left</sub></code> 和 <code>t<sub>right</sub></code> 可能为 <strong>空</strong> 。</li>
+</ul>
+
+<p>如果字符串 <code>s</code> 有效，则返回 <code>true</code>；否则，返回 <code>false</code>。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "aabcbc"
+<strong>输出：</strong>true
+<strong>解释：</strong>
+"" -> "<strong>abc</strong>" -> "a<strong>abc</strong>bc"
+因此，"aabcbc" 有效。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "abcabcababcc"
+<strong>输出：</strong>true
+<strong>解释：</strong>
+"" -> "<strong>abc</strong>" -> "abc<strong>abc</strong>" -> "abcabc<strong>abc</strong>" -> "abcabcab<strong>abc</strong>c"
+因此，"abcabcababcc" 有效。</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "abccba"
+<strong>输出：</strong>false
+<strong>解释：</strong>执行操作无法得到 "abccba" 。</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "cababc"
+<strong>输出：</strong>false
+<strong>解释：</strong>执行操作无法得到 "cababc" 。</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= s.length <= 2 * 10<sup>4</sup></code></li>
+	<li><code>s</code> 由字母 <code>'a'</code>、<code>'b'</code> 和 <code>'c'</code> 组成</li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1004-最大连续1的个数 III/solution.md

+# 两数之和
+
+<p>给定一个由若干 <code>0</code> 和 <code>1</code> 组成的数组&nbsp;<code>A</code>，我们最多可以将&nbsp;<code>K</code>&nbsp;个值从 0 变成 1 。</p>
+
+<p>返回仅包含 1 的最长（连续）子数组的长度。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
+<strong>输出：</strong>6
+<strong>解释： </strong>
+[1,1,1,0,0,<strong>1</strong>,1,1,1,1,<strong>1</strong>]
+粗体数字从 0 翻转到 1，最长的子数组长度为 6。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3
+<strong>输出：</strong>10
+<strong>解释：</strong>
+[0,0,1,1,<strong>1</strong>,<strong>1</strong>,1,1,1,<strong>1</strong>,1,1,0,0,0,1,1,1,1]
+粗体数字从 0 翻转到 1，最长的子数组长度为 10。</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= A.length &lt;= 20000</code></li>
+	<li><code>0 &lt;= K &lt;= A.length</code></li>
+	<li><code>A[i]</code> 为&nbsp;<code>0</code>&nbsp;或&nbsp;<code>1</code>&nbsp;</li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1005-K 次取反后最大化的数组和/solution.md

+# 两数之和
+
+<p>给定一个整数数组 A，我们<strong>只能</strong>用以下方法修改该数组：我们选择某个索引 <code>i</code>&nbsp;并将 <code>A[i]</code> 替换为 <code>-A[i]</code>，然后总共重复这个过程 <code>K</code> 次。（我们可以多次选择同一个索引 <code>i</code>。）</p>
+
+<p>以这种方式修改数组后，返回数组可能的最大和。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>A = [4,2,3], K = 1
+<strong>输出：</strong>5
+<strong>解释：</strong>选择索引 (1,) ，然后 A 变为 [4,-2,3]。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>A = [3,-1,0,2], K = 3
+<strong>输出：</strong>6
+<strong>解释：</strong>选择索引 (1, 2, 2) ，然后 A 变为 [3,1,0,2]。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>A = [2,-3,-1,5,-4], K = 2
+<strong>输出：</strong>13
+<strong>解释：</strong>选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= A.length &lt;= 10000</code></li>
+	<li><code>1 &lt;= K &lt;= 10000</code></li>
+	<li><code>-100 &lt;= A[i] &lt;= 100</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1006-笨阶乘/solution.md

+# 两数之和
+
+<p>通常，正整数 <code>n</code> 的阶乘是所有小于或等于 <code>n</code> 的正整数的乘积。例如，<code>factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1</code>。</p>
+
+<p>相反，我们设计了一个笨阶乘 <code>clumsy</code>：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。</p>
+
+<p>例如，<code>clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1</code>。然而，这些运算仍然使用通常的算术运算顺序：我们在任何加、减步骤之前执行所有的乘法和除法步骤，并且按从左到右处理乘法和除法步骤。</p>
+
+<p>另外，我们使用的除法是地板除法（<em>floor division</em>），所以&nbsp;<code>10 * 9 / 8</code>&nbsp;等于&nbsp;<code>11</code>。这保证结果是一个整数。</p>
+
+<p>实现上面定义的笨函数：给定一个整数 <code>N</code>，它返回 <code>N</code> 的笨阶乘。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>4
+<strong>输出：</strong>7
+<strong>解释：</strong>7 = 4 * 3 / 2 + 1
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>10
+<strong>输出：</strong>12
+<strong>解释：</strong>12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= N &lt;= 10000</code></li>
+	<li><code>-2^31 &lt;= answer &lt;= 2^31 - 1</code>&nbsp; （答案保证符合 32 位整数。）</li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1007-行相等的最少多米诺旋转/solution.md

+# 两数之和
+
+<p>在一排多米诺骨牌中，<code>A[i]</code> 和 <code>B[i]</code>&nbsp;分别代表第 i 个多米诺骨牌的上半部分和下半部分。（一个多米诺是两个从 1 到 6 的数字同列平铺形成的&nbsp;&mdash;&mdash; 该平铺的每一半上都有一个数字。）</p>
+
+<p>我们可以旋转第&nbsp;<code>i</code>&nbsp;张多米诺，使得&nbsp;<code>A[i]</code> 和&nbsp;<code>B[i]</code>&nbsp;的值交换。</p>
+
+<p>返回能使 <code>A</code> 中所有值或者 <code>B</code> 中所有值都相同的最小旋转次数。</p>
+
+<p>如果无法做到，返回&nbsp;<code>-1</code>.</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/03/08/domino.png" style="height: 161px; width: 200px;"></p>
+
+<pre><strong>输入：</strong>A = [2,1,2,4,2,2], B = [5,2,6,2,3,2]
+<strong>输出：</strong>2
+<strong>解释：</strong>
+图一表示：在我们旋转之前， A 和 B 给出的多米诺牌。
+如果我们旋转第二个和第四个多米诺骨牌，我们可以使上面一行中的每个值都等于 2，如图二所示。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>A = [3,5,1,2,3], B = [3,6,3,3,4]
+<strong>输出：</strong>-1
+<strong>解释：</strong>
+在这种情况下，不可能旋转多米诺牌使一行的值相等。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= A[i], B[i] &lt;= 6</code></li>
+	<li><code>2 &lt;= A.length == B.length &lt;= 20000</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1008-前序遍历构造二叉搜索树/solution.md

+# 两数之和
+
+<p>返回与给定前序遍历&nbsp;<code>preorder</code> 相匹配的二叉搜索树（binary <strong>search</strong> tree）的根结点。</p>
+
+<p><em>(回想一下，二叉搜索树是二叉树的一种，其每个节点都满足以下规则，对于&nbsp;<code>node.left</code>&nbsp;的任何后代，值总 <code>&lt; node.val</code>，而 <code>node.right</code> 的任何后代，值总 <code>&gt; node.val</code>。此外，前序遍历首先显示节点&nbsp;<code>node</code> 的值，然后遍历 <code>node.left</code>，接着遍历 <code>node.right</code>。）</em></p>
+
+<p>题目保证，对于给定的测试用例，总能找到满足要求的二叉搜索树。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例：</strong></p>
+
+<pre><strong>输入：</strong>[8,5,1,7,10,12]
+<strong>输出：</strong>[8,5,10,1,7,null,12]
+<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/03/08/1266.png" style="height: 200px; width: 306px;">
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= preorder.length &lt;= 100</code></li>
+	<li><code>1 &lt;= preorder[i]&nbsp;&lt;= 10^8</code></li>
+	<li><code>preorder</code> 中的值互不相同</li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1009-十进制整数的反码/solution.md

+# 两数之和
+
+<p>每个非负整数&nbsp;<code>N</code>&nbsp;都有其二进制表示。例如，&nbsp;<code>5</code>&nbsp;可以被表示为二进制&nbsp;<code>&quot;101&quot;</code>，<code>11</code> 可以用二进制&nbsp;<code>&quot;1011&quot;</code>&nbsp;表示，依此类推。注意，除&nbsp;<code>N = 0</code>&nbsp;外，任何二进制表示中都不含前导零。</p>
+
+<p>二进制的反码表示是将每个&nbsp;<code>1</code>&nbsp;改为&nbsp;<code>0</code>&nbsp;且每个&nbsp;<code>0</code>&nbsp;变为&nbsp;<code>1</code>。例如，二进制数&nbsp;<code>&quot;101&quot;</code>&nbsp;的二进制反码为&nbsp;<code>&quot;010&quot;</code>。</p>
+
+<p>给你一个十进制数&nbsp;<code>N</code>，请你返回其二进制表示的反码所对应的十进制整数。</p>
+
+<p>&nbsp;</p>
+
+<ol>
+</ol>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>5
+<strong>输出：</strong>2
+<strong>解释：</strong>5 的二进制表示为 &quot;101&quot;，其二进制反码为 &quot;010&quot;，也就是十进制中的 2 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>7
+<strong>输出：</strong>0
+<strong>解释：</strong>7 的二进制表示为 &quot;111&quot;，其二进制反码为 &quot;000&quot;，也就是十进制中的 0 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>10
+<strong>输出：</strong>5
+<strong>解释：</strong>10 的二进制表示为 &quot;1010&quot;，其二进制反码为 &quot;0101&quot;，也就是十进制中的 5 。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>0 &lt;= N &lt; 10^9</code></li>
+	<li>本题与 476：<a href="https://leetcode-cn.com/problems/number-complement/">https://leetcode-cn.com/problems/number-complement/</a> 相同</li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1010-总持续时间可被 60 整除的歌曲/solution.md

+# 两数之和
+
+<p>在歌曲列表中，第 <code>i</code> 首歌曲的持续时间为 <code>time[i]</code> 秒。</p>
+
+<p>返回其总持续时间（以秒为单位）可被 <code>60</code> 整除的歌曲对的数量。形式上，我们希望索引的数字 <code>i</code> 和 <code>j</code> 满足&nbsp; <code>i &lt; j</code> 且有&nbsp;<code>(time[i] + time[j]) % 60 == 0</code>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>[30,20,150,100,40]
+<strong>输出：</strong>3
+<strong>解释：</strong>这三对的总持续时间可被 60 整数：
+(time[0] = 30, time[2] = 150): 总持续时间 180
+(time[1] = 20, time[3] = 100): 总持续时间 120
+(time[1] = 20, time[4] = 40): 总持续时间 60
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>[60,60,60]
+<strong>输出：</strong>3
+<strong>解释：</strong>所有三对的总持续时间都是 120，可以被 60 整数。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= time.length &lt;= 60000</code></li>
+	<li><code>1 &lt;= time[i] &lt;= 500</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1011-在 D 天内送达包裹的能力/solution.md

+# 两数之和
+
+<p>传送带上的包裹必须在 D 天内从一个港口运送到另一个港口。</p>
+
+<p>传送带上的第 <code>i</code> 个包裹的重量为 <code>weights[i]</code>。每一天，我们都会按给出重量的顺序往传送带上装载包裹。我们装载的重量不会超过船的最大运载重量。</p>
+
+<p>返回能在 <code>D</code> 天内将传送带上的所有包裹送达的船的最低运载能力。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>weights = [1,2,3,4,5,6,7,8,9,10], D = 5
+<strong>输出：</strong>15
+<strong>解释：</strong>
+船舶最低载重 15 就能够在 5 天内送达所有包裹，如下所示：
+第 1 天：1, 2, 3, 4, 5
+第 2 天：6, 7
+第 3 天：8
+第 4 天：9
+第 5 天：10
+
+请注意，货物必须按照给定的顺序装运，因此使用载重能力为 14 的船舶并将包装分成 (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) 是不允许的。 
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>weights = [3,2,2,4,1,4], D = 3
+<strong>输出：</strong>6
+<strong>解释：</strong>
+船舶最低载重 6 就能够在 3 天内送达所有包裹，如下所示：
+第 1 天：3, 2
+第 2 天：2, 4
+第 3 天：1, 4
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>weights = [1,2,3,1,1], D = 4
+<strong>输出：</strong>3
+<strong>解释：</strong>
+第 1 天：1
+第 2 天：2
+第 3 天：3
+第 4 天：1, 1
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= D <= weights.length <= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 <= weights[i] <= 500</code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1012-至少有 1 位重复的数字/solution.md

+# 两数之和
+
+<p>给定正整数&nbsp;<code>N</code>，返回小于等于 <code>N</code>&nbsp;且具有至少 1 位重复数字的正整数的个数。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>20
+<strong>输出：</strong>1
+<strong>解释：</strong>具有至少 1 位重复数字的正数（&lt;= 20）只有 11 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>100
+<strong>输出：</strong>10
+<strong>解释：</strong>具有至少 1 位重复数字的正数（&lt;= 100）有 11，22，33，44，55，66，77，88，99 和 100 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>1000
+<strong>输出：</strong>262
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= N &lt;= 10^9</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1013-将数组分成和相等的三个部分/solution.md

+# 两数之和
+
+<p>给你一个整数数组 <code>arr</code>，只有可以将其划分为三个和相等的 <strong>非空</strong> 部分时才返回 <code>true</code>，否则返回 <code>false</code>。</p>
+
+<p>形式上，如果可以找出索引 <code>i + 1 < j</code> 且满足 <code>(arr[0] + arr[1] + ... + arr[i] == arr[i + 1] + arr[i + 2] + ... + arr[j - 1] == arr[j] + arr[j + 1] + ... + arr[arr.length - 1])</code> 就可以将数组三等分。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>arr = [0,2,1,-6,6,-7,9,1,2,0,1]
+<strong>输出：</strong>true
+<strong>解释：</strong>0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>arr = [0,2,1,-6,6,7,9,-1,2,0,1]
+<strong>输出：</strong>false
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>arr = [3,3,6,5,-2,2,5,1,-9,4]
+<strong>输出：</strong>true
+<strong>解释：</strong>3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>3 <= arr.length <= 5 * 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> <= arr[i] <= 10<sup>4</sup></code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1014-最佳观光组合/solution.md

+# 两数之和
+
+<p>给你一个正整数数组 <code>values</code>，其中 <code>values[i]</code> 表示第 <code>i</code> 个观光景点的评分，并且两个景点 <code>i</code> 和 <code>j</code> 之间的 <strong>距离</strong> 为 <code>j - i</code>。</p>
+
+<p>一对景点（<code>i < j</code>）组成的观光组合的得分为 <code>values[i] + values[j] + i - j</code> ，也就是景点的评分之和<strong> 减去 </strong>它们两者之间的距离。</p>
+
+<p>返回一对观光景点能取得的最高分。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>values = [8,1,5,2,6]
+<strong>输出：</strong>11
+<strong>解释：</strong>i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>values = [1,2]
+<strong>输出：</strong>2
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 <= values.length <= 5 * 10<sup>4</sup></code></li>
+	<li><code>1 <= values[i] <= 1000</code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1015-可被 K 整除的最小整数/solution.md

+# 两数之和
+
+<p>给定正整数&nbsp;<code>K</code>，你需要找出可以被 K 整除的、仅包含数字 <strong>1</strong> 的最小正整数 N。</p>
+
+<p>返回&nbsp;<code>N</code>&nbsp;的长度。如果不存在这样的&nbsp;<code>N</code>，就返回 <code>-1</code>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>1
+<strong>输出：</strong>1
+<strong>解释：</strong>最小的答案是 N = 1，其长度为 1。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>2
+<strong>输出：</strong>-1
+<strong>解释：</strong>不存在可被 2 整除的正整数 N 。</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>3
+<strong>输出：</strong>3
+<strong>解释：</strong>最小的答案是 N = 111，其长度为 3。</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= K &lt;= 10^5</code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1016-子串能表示从 1 到 N 数字的二进制串/solution.md

+# 两数之和
+
+<p>给定一个二进制字符串&nbsp;<code>S</code>（一个仅由若干&nbsp;&#39;0&#39; 和 &#39;1&#39; 构成的字符串）和一个正整数&nbsp;<code>N</code>，如果对于从 <code>1</code> 到 <code>N</code> 的每个整数 <code>X</code>，其二进制表示都是&nbsp;<code>S</code> 的子串，就返回 <code>true</code>，否则返回 <code>false</code>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>S = &quot;0110&quot;, N = 3
+<strong>输出：</strong>true
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>S = &quot;0110&quot;, N = 4
+<strong>输出：</strong>false
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= S.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= N &lt;= 10^9</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1017-负二进制转换/solution.md

+# 两数之和
+
+<p>给出数字&nbsp;<code>N</code>，返回由若干&nbsp;<code>&quot;0&quot;</code>&nbsp;和&nbsp;<code>&quot;1&quot;</code>组成的字符串，该字符串为 <code>N</code>&nbsp;的<strong>负二进制（<code>base -2</code>）</strong>表示。</p>
+
+<p>除非字符串就是&nbsp;<code>&quot;0&quot;</code>，否则返回的字符串中不能含有前导零。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>2
+<strong>输出：</strong>&quot;110&quot;
+<strong>解释：</strong>(-2) ^ 2 + (-2) ^ 1 = 2
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>3
+<strong>输出：</strong>&quot;111&quot;
+<strong>解释：</strong>(-2) ^ 2 + (-2) ^ 1 + (-2) ^ 0 = 3
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>4
+<strong>输出：</strong>&quot;100&quot;
+<strong>解释：</strong>(-2) ^ 2 = 4
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>0 &lt;= N &lt;= 10^9</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1018-可被 5 整除的二进制前缀/solution.md

+# 两数之和
+
+<p>给定由若干&nbsp;<code>0</code>&nbsp;和&nbsp;<code>1</code>&nbsp;组成的数组 <code>A</code>。我们定义&nbsp;<code>N_i</code>：从&nbsp;<code>A[0]</code> 到&nbsp;<code>A[i]</code>&nbsp;的第 <code>i</code>&nbsp;个子数组被解释为一个二进制数（从最高有效位到最低有效位）。</p>
+
+<p>返回布尔值列表&nbsp;<code>answer</code>，只有当&nbsp;<code>N_i</code>&nbsp;可以被 <code>5</code>&nbsp;整除时，答案&nbsp;<code>answer[i]</code> 为&nbsp;<code>true</code>，否则为 <code>false</code>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>[0,1,1]
+<strong>输出：</strong>[true,false,false]
+<strong>解释：</strong>
+输入数字为 0, 01, 011；也就是十进制中的 0, 1, 3 。只有第一个数可以被 5 整除，因此 answer[0] 为真。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>[1,1,1]
+<strong>输出：</strong>[false,false,false]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>[0,1,1,1,1,1]
+<strong>输出：</strong>[true,false,false,false,true,false]
+</pre>
+
+<p><strong>示例&nbsp;4：</strong></p>
+
+<pre><strong>输入：</strong>[1,1,1,0,1]
+<strong>输出：</strong>[false,false,false,false,false]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= A.length &lt;= 30000</code></li>
+	<li><code>A[i]</code> 为&nbsp;<code>0</code>&nbsp;或&nbsp;<code>1</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1019-链表中的下一个更大节点/solution.md

+# 两数之和
+
+<p>给出一个以头节点&nbsp;<code>head</code>&nbsp;作为第一个节点的链表。链表中的节点分别编号为：<code>node_1, node_2, node_3, ...</code> 。</p>
+
+<p>每个节点都可能有下一个更大值（<em>next larger</em> <strong>value</strong>）：对于&nbsp;<code>node_i</code>，如果其&nbsp;<code>next_larger(node_i)</code>&nbsp;是&nbsp;<code>node_j.val</code>，那么就有&nbsp;<code>j &gt; i</code>&nbsp;且&nbsp;&nbsp;<code>node_j.val &gt; node_i.val</code>，而&nbsp;<code>j</code>&nbsp;是可能的选项中最小的那个。如果不存在这样的&nbsp;<code>j</code>，那么下一个更大值为&nbsp;<code>0</code>&nbsp;。</p>
+
+<p>返回整数答案数组&nbsp;<code>answer</code>，其中&nbsp;<code>answer[i] = next_larger(node_{i+1})</code>&nbsp;。</p>
+
+<p><strong><em>注意：</em></strong>在下面的示例中，诸如 <code>[2,1,5]</code> 这样的<strong>输入</strong>（不是输出）是链表的序列化表示，其头节点的值为&nbsp;2，第二个节点值为 1，第三个节点值为&nbsp;5 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>[2,1,5]
+<strong>输出：</strong>[5,5,0]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>[2,7,4,3,5]
+<strong>输出：</strong>[7,0,5,5,0]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>[1,7,5,1,9,2,5,1]
+<strong>输出：</strong>[7,9,9,9,0,5,0,0]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li>对于链表中的每个节点，<code>1 &lt;= node.val&nbsp;&lt;= 10^9</code></li>
+	<li>给定列表的长度在 <code>[0, 10000]</code>&nbsp;范围内</li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1020-飞地的数量/solution.md

+# 两数之和
+
+<p>给出一个二维数组&nbsp;<code>A</code>，每个单元格为 0（代表海）或 1（代表陆地）。</p>
+
+<p>移动是指在陆地上从一个地方走到另一个地方（朝四个方向之一）或离开网格的边界。</p>
+
+<p>返回网格中<strong>无法</strong>在任意次数的移动中离开网格边界的陆地单元格的数量。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>[[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
+<strong>输出：</strong>3
+<strong>解释： </strong>
+有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>[[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
+<strong>输出：</strong>0
+<strong>解释：</strong>
+所有 1 都在边界上或可以到达边界。</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= A.length &lt;= 500</code></li>
+	<li><code>1 &lt;= A[i].length &lt;= 500</code></li>
+	<li><code>0 &lt;= A[i][j] &lt;= 1</code></li>
+	<li>所有行的大小都相同</li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1021-删除最外层的括号/solution.md

+# 两数之和
+
+<p>有效括号字符串为空 <code>""</code>、<code>"(" + A + ")"</code> 或 <code>A + B</code> ，其中 <code>A</code> 和 <code>B</code> 都是有效的括号字符串，<code>+</code> 代表字符串的连接。</p>
+
+<ul>
+	<li>例如，<code>""</code>，<code>"()"</code>，<code>"(())()"</code> 和 <code>"(()(()))"</code> 都是有效的括号字符串。</li>
+</ul>
+
+<p>如果有效字符串 <code>s</code> 非空，且不存在将其拆分为 <code>s = A + B</code> 的方法，我们称其为<strong>原语（primitive）</strong>，其中 <code>A</code> 和 <code>B</code> 都是非空有效括号字符串。</p>
+
+<p>给出一个非空有效字符串 <code>s</code>，考虑将其进行原语化分解，使得：<code>s = P_1 + P_2 + ... + P_k</code>，其中 <code>P_i</code> 是有效括号字符串原语。</p>
+
+<p>对 <code>s</code> 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 <code>s</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "(()())(())"
+<strong>输出：</strong>"()()()"
+<strong>解释：
+</strong>输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，
+删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "(()())(())(()(()))"
+<strong>输出：</strong>"()()()()(())"
+<strong>解释：</strong>
+输入字符串为 "(()())(())(()(()))"，原语化分解得到 "(()())" + "(())" + "(()(()))"，
+删除每个部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "()()"
+<strong>输出：</strong>""
+<strong>解释：</strong>
+输入字符串为 "()()"，原语化分解得到 "()" + "()"，
+删除每个部分中的最外层括号后得到 "" + "" = ""。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= s.length <= 10<sup>5</sup></code></li>
+	<li><code>s[i]</code> 为 <code>'('</code> 或 <code>')'</code></li>
+	<li><code>s</code> 是一个有效括号字符串</li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1022-从根到叶的二进制数之和/solution.md

+# 两数之和
+
+<p>给出一棵二叉树，其上每个结点的值都是 <code>0</code> 或 <code>1</code> 。每一条从根到叶的路径都代表一个从最高有效位开始的二进制数。例如，如果路径为 <code>0 -> 1 -> 1 -> 0 -> 1</code>，那么它表示二进制数 <code>01101</code>，也就是 <code>13</code> 。</p>
+
+<p>对树上的每一片叶子，我们都要找出从根到该叶子的路径所表示的数字。</p>
+
+<p>返回这些数字之和。题目数据保证答案是一个 <strong>32 位 </strong>整数。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2019/04/04/sum-of-root-to-leaf-binary-numbers.png" style="width: 450px; height: 296px;" />
+<pre>
+<strong>输入：</strong>root = [1,0,1,0,1,0,1]
+<strong>输出：</strong>22
+<strong>解释：</strong>(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = [0]
+<strong>输出：</strong>0
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = [1]
+<strong>输出：</strong>1
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>root = [1,1]
+<strong>输出：</strong>3
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中的结点数介于 <code>1</code> 和 <code>1000</code> 之间。</li>
+	<li><code>Node.val</code> 为 <code>0</code> 或 <code>1</code> 。</li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1023-驼峰式匹配/solution.md

+# 两数之和
+
+<p>如果我们可以将<strong>小写字母</strong>插入模式串&nbsp;<code>pattern</code>&nbsp;得到待查询项&nbsp;<code>query</code>，那么待查询项与给定模式串匹配。（我们可以在任何位置插入每个字符，也可以插入 0 个字符。）</p>
+
+<p>给定待查询列表&nbsp;<code>queries</code>，和模式串&nbsp;<code>pattern</code>，返回由布尔值组成的答案列表&nbsp;<code>answer</code>。只有在待查项&nbsp;<code>queries[i]</code> 与模式串&nbsp;<code>pattern</code> 匹配时，&nbsp;<code>answer[i]</code>&nbsp;才为 <code>true</code>，否则为 <code>false</code>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>queries = [&quot;FooBar&quot;,&quot;FooBarTest&quot;,&quot;FootBall&quot;,&quot;FrameBuffer&quot;,&quot;ForceFeedBack&quot;], pattern = &quot;FB&quot;
+<strong>输出：</strong>[true,false,true,true,false]
+<strong>示例：</strong>
+&quot;FooBar&quot; 可以这样生成：&quot;F&quot; + &quot;oo&quot; + &quot;B&quot; + &quot;ar&quot;。
+&quot;FootBall&quot; 可以这样生成：&quot;F&quot; + &quot;oot&quot; + &quot;B&quot; + &quot;all&quot;.
+&quot;FrameBuffer&quot; 可以这样生成：&quot;F&quot; + &quot;rame&quot; + &quot;B&quot; + &quot;uffer&quot;.</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>queries = [&quot;FooBar&quot;,&quot;FooBarTest&quot;,&quot;FootBall&quot;,&quot;FrameBuffer&quot;,&quot;ForceFeedBack&quot;], pattern = &quot;FoBa&quot;
+<strong>输出：</strong>[true,false,true,false,false]
+<strong>解释：</strong>
+&quot;FooBar&quot; 可以这样生成：&quot;Fo&quot; + &quot;o&quot; + &quot;Ba&quot; + &quot;r&quot;.
+&quot;FootBall&quot; 可以这样生成：&quot;Fo&quot; + &quot;ot&quot; + &quot;Ba&quot; + &quot;ll&quot;.
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输出：</strong>queries = [&quot;FooBar&quot;,&quot;FooBarTest&quot;,&quot;FootBall&quot;,&quot;FrameBuffer&quot;,&quot;ForceFeedBack&quot;], pattern = &quot;FoBaT&quot;
+<strong>输入：</strong>[false,true,false,false,false]
+<strong>解释： </strong>
+&quot;FooBarTest&quot; 可以这样生成：&quot;Fo&quot; + &quot;o&quot; + &quot;Ba&quot; + &quot;r&quot; + &quot;T&quot; + &quot;est&quot;.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= queries.length &lt;= 100</code></li>
+	<li><code>1 &lt;= queries[i].length &lt;= 100</code></li>
+	<li><code>1 &lt;= pattern.length &lt;= 100</code></li>
+	<li>所有字符串都仅由大写和小写英文字母组成。</li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1024-视频拼接/solution.md

+# 两数之和
+
+<p>你将会获得一系列视频片段，这些片段来自于一项持续时长为 <code>T</code> 秒的体育赛事。这些片段可能有所重叠，也可能长度不一。</p>
+
+<p>视频片段 <code>clips[i]</code> 都用区间进行表示：开始于 <code>clips[i][0]</code> 并于 <code>clips[i][1]</code> 结束。我们甚至可以对这些片段自由地再剪辑，例如片段 <code>[0, 7]</code> 可以剪切成 <code>[0, 1] + [1, 3] + [3, 7]</code> 三部分。</p>
+
+<p>我们需要将这些片段进行再剪辑，并将剪辑后的内容拼接成覆盖整个运动过程的片段（<code>[0, T]</code>）。返回所需片段的最小数目，如果无法完成该任务，则返回 <code>-1</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], T = 10
+<strong>输出：</strong>3
+<strong>解释：</strong>
+我们选中 [0,2], [8,10], [1,9] 这三个片段。
+然后，按下面的方案重制比赛片段：
+将 [1,9] 再剪辑为 [1,2] + [2,8] + [8,9] 。
+现在我们手上有 [0,2] + [2,8] + [8,10]，而这些涵盖了整场比赛 [0, 10]。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>clips = [[0,1],[1,2]], T = 5
+<strong>输出：</strong>-1
+<strong>解释：</strong>
+我们无法只用 [0,1] 和 [1,2] 覆盖 [0,5] 的整个过程。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,5],[5,7],[6,9]], T = 9
+<strong>输出：</strong>3
+<strong>解释： </strong>
+我们选取片段 [0,4], [4,7] 和 [6,9] 。
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>clips = [[0,4],[2,8]], T = 5
+<strong>输出：</strong>2
+<strong>解释：</strong>
+注意，你可能录制超过比赛结束时间的视频。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= clips.length <= 100</code></li>
+	<li><code>0 <= clips[i][0] <= clips[i][1] <= 100</code></li>
+	<li><code>0 <= T <= 100</code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1025-除数博弈/solution.md

+# 两数之和
+
+<p>爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。</p>
+
+<p>最初，黑板上有一个数字&nbsp;<code>N</code>&nbsp;。在每个玩家的回合，玩家需要执行以下操作：</p>
+
+<ul>
+	<li>选出任一&nbsp;<code>x</code>，满足&nbsp;<code>0 &lt; x &lt; N</code> 且&nbsp;<code>N % x == 0</code>&nbsp;。</li>
+	<li>用 <code>N - x</code>&nbsp;替换黑板上的数字 <code>N</code> 。</li>
+</ul>
+
+<p>如果玩家无法执行这些操作，就会输掉游戏。</p>
+
+<p>只有在爱丽丝在游戏中取得胜利时才返回&nbsp;<code>True</code>，否则返回 <code>False</code>。假设两个玩家都以最佳状态参与游戏。</p>
+
+<p>&nbsp;</p>
+
+<ol>
+</ol>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>2
+<strong>输出：</strong>true
+<strong>解释：</strong>爱丽丝选择 1，鲍勃无法进行操作。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>3
+<strong>输出：</strong>false
+<strong>解释：</strong>爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>1 &lt;= N &lt;= 1000</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1026-节点与其祖先之间的最大差值/solution.md

+# 两数之和
+
+<p>给定二叉树的根节点 <code>root</code>，找出存在于 <strong>不同</strong> 节点 <code>A</code> 和 <code>B</code> 之间的最大值 <code>V</code>，其中 <code>V = |A.val - B.val|</code>，且 <code>A</code> 是 <code>B</code> 的祖先。</p>
+
+<p>（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree.jpg" style="width: 400px; height: 390px;" /></p>
+
+<pre>
+<strong>输入：</strong>root = [8,3,10,1,6,null,14,null,null,4,7,13]
+<strong>输出：</strong>7
+<strong>解释： </strong>
+我们有大量的节点与其祖先的差值，其中一些如下：
+|8 - 3| = 5
+|3 - 7| = 4
+|8 - 1| = 7
+|10 - 13| = 3
+在所有可能的差值中，最大值 7 由 |8 - 1| = 7 得出。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/11/09/tmp-tree-1.jpg" style="width: 250px; height: 349px;" />
+<pre>
+<strong>输入：</strong>root = [1,null,2,null,0,3]
+<strong>输出：</strong>3
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中的节点数在 <code>2</code> 到 <code>5000</code> 之间。</li>
+	<li><code>0 <= Node.val <= 10<sup>5</sup></code></li>
+</ul>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/1027-最长等差数列/solution.md

+# 两数之和
+
+<p>给定一个整数数组&nbsp;<code>A</code>，返回 <code>A</code>&nbsp;中最长等差子序列的<strong>长度</strong>。</p>
+
+<p>回想一下，<code>A</code>&nbsp;的子序列是列表&nbsp;<code>A[i_1], A[i_2], ..., A[i_k]</code> 其中&nbsp;<code>0 &lt;= i_1 &lt; i_2 &lt; ... &lt; i_k &lt;= A.length - 1</code>。并且如果&nbsp;<code>B[i+1] - B[i]</code>(&nbsp;<code>0 &lt;= i &lt; B.length - 1</code>) 的值都相同，那么序列&nbsp;<code>B</code>&nbsp;是等差的。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>[3,6,9,12]
+<strong>输出：</strong>4
+<strong>解释： </strong>
+整个数组是公差为 3 的等差数列。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>[9,4,7,2,10]
+<strong>输出：</strong>3
+<strong>解释：</strong>
+最长的等差子序列是 [4,7,10]。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>[20,1,15,3,10,5,8]
+<strong>输出：</strong>4
+<strong>解释：</strong>
+最长的等差子序列是 [20,15,10,5]。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ol>
+	<li><code>2 &lt;= A.length &lt;= 2000</code></li>
+	<li><code>0 &lt;= A[i] &lt;= 10000</code></li>
+</ol>
+
+<p>以下错误的选项是？</p>
+
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data_backup/1.leetcode/104-二叉树的最大深度/solution.md

 # 二叉树的最大深度
+
 <p>给定一个二叉树，找出其最大深度。</p>
 
 <p>二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。</p>
@@ -17,6 +18,7 @@
 <p>返回它的最大深度&nbsp;3 。</p>
 
 <p>以下错误的选项是？</p>
+
 ## aop
 ### before
 ```cpp

data_backup/1.leetcode/105-从前序与中序遍历序列构造二叉树/solution.md

 # 从前序与中序遍历序列构造二叉树
+
 <p>给定一棵树的前序遍历 <code>preorder</code> 与中序遍历  <code>inorder</code>。请构造二叉树并返回其根节点。</p>
 
 <p> </p>
@@ -32,6 +33,7 @@
 </ul>
 
 <p>以下错误的选项是？</p>
+
 ## aop
 ### before
 ```cpp

data_backup/1.leetcode/112-路径总和/solution.md

 # 路径总和
+
 <p>给你二叉树的根节点 <code>root</code> 和一个表示目标和的整数 <code>targetSum</code> ，判断该树中是否存在 <strong>根节点到叶子节点</strong> 的路径，这条路径上所有节点值相加等于目标和 <code>targetSum</code> 。</p>
 
 <p><strong>叶子节点</strong> 是指没有子节点的节点。</p>