修正格式

.gitignore

@@ -10,4 +10,4 @@ test.md
 data_source/dailycode
 test.cpp
 test.py
-test.java
\ No newline at end of file
+test.java

data_source/1.leetcode/1-两数之和/config.json

+{
+  "node_id": "algorithm-801b7eed64a54195806b20b5da3664c3",
+  "keywords": [
+    "leetcode",
+    "两数之和"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1-两数之和/desc.html

+<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>
\ No newline at end of file

data_source/1.leetcode/1-两数之和/solution.cpp

+#include <unordered_map>
+#include <vector>
+#include <iostream>
+using namespace std;
+class Solution
+{
+public:
+	vector<int> twoSum(vector<int> &nums, int target)
+	{
+		std::unordered_map<int, int> hset;
+		vector<int> r;
+		for (int i = 0; i < nums.size(); ++i)
+		{
+			int c = target - nums[i];
+			auto iter = hset.find(c);
+			if (iter != hset.end() && iter->second != i)
+			{
+				r.push_back(i);
+				r.push_back(iter->second);
+				return r;
+			}
+			hset.insert(std::make_pair(nums[i], i));
+		}
+		return r;
+	}
+};
+
+int main()
+{
+	Solution test;
+	int arr[] = {3, 2, 4};
+	vector<int> ret;
+	vector<int> vec(arr, arr + 4);
+	ret = test.twoSum(vec, 6);
+	for (auto i = ret.begin(); i != ret.end(); i++)
+	{
+		cout << *i << ' ';
+	}
+	return 0;
+}

data_source/1.leetcode/1-两数之和/solution.json

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

data_source/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
+#include <unordered_map>
+#include <vector>
+#include <iostream>
+#include <map>
+using namespace std;
+```
+### after
+
+```cpp
+int main()
+{
+	Solution test;
+	int arr[] = {3,2,4};
+	vector<int> ret;
+	vector<int> vec(arr, arr+4);
+	ret = test.twoSum(vec, 6);
+	for (auto i = ret.begin(); i != ret.end(); i++)
+	{
+		cout << *i << ' ';
+	}
+	return 0;
+}
+```
+
+## 答案
+
+```cpp
+class Solution
+{
+public:
+    vector<int> twoSum(vector<int> &nums, int target)
+    {
+        vector<int> vec;
+        map<int, int> dic; 
+        for (int i = 0; i < nums.size(); ++i)
+        {
+            dic[nums[i]] = i;
+        }
+        for (int i = 0; i < nums.size(); ++i)
+        {
+            if (dic.count(target - nums[i]) != 0 && dic[target - nums[i]] != i)
+            {
+                vec.push_back(i);
+                vec.push_back(dic[target]);
+                break;
+            }
+        }
+        return vec;
+    }
+};
+```
+
+## 选项
+
+
+### A
+
+```cpp
+class Solution
+{
+public:
+    vector<int> twoSum(vector<int> &nums, int target)
+    {
+        vector<int> a;
+        map<int, int> map;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            map[nums[i]] = i;
+        }
+        for (int j = 0; j < nums.size(); j++)
+        {
+            if (map.count(target - nums[j]) == 1 && map[target - nums[j]] != j)
+            {
+                a.push_back(j);
+                a.push_back(map[target - nums[j]]);
+                return a;
+            }
+        }
+        return a;
+    }
+};
+```
+
+### B
+
+```cpp
+class Solution
+{
+public:
+    vector<int> twoSum(vector<int> &nums, int target)
+    {
+        vector<int> a;
+        map<int, int> map;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (map.find(target - nums[i]) != map.end())
+            {
+                a.push_back(map[target - nums[i]]);
+                a.push_back(i);
+                return a;
+            }
+            else
+            {
+                map[nums[i]] = i;
+            }
+        }
+        return a;
+    }
+};
+```
+
+### C
+
+```cpp
+class Solution
+{
+public:
+    vector<int> twoSum(vector<int> &nums, int target)
+    {
+        vector<int> a;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            for (int j = i + 1; j < nums.size(); j++)
+            {
+                if (nums[i] + nums[j] == target)
+                {
+                    a.push_back(i);
+                    a.push_back(j);
+                    return a;
+                }
+            }
+        }
+    }
+};
+```

data_source/1.leetcode/10-正则表达式匹配/config.json

+{
+  "node_id": "algorithm-f16d06ef304b477f86596c8e4bd784d5",
+  "keywords": [
+    "leetcode",
+    "正则表达式匹配"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/10-正则表达式匹配/desc.html

+<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>
\ No newline at end of file

data_source/1.leetcode/10-正则表达式匹配/solution.cpp

+bool isMatch(char *s, char *p)
+{
+	if (!p || p[0] == NULL)
+		return (!s || s[0] == NULL);
+	bool head_match = (s && s[0] && (s[0] == p[0] || p[0] == '.'));
+	if (p[1] && p[1] == '*')
+	{
+		return (head_match && isMatch(s + 1, p)) || isMatch(s, p + 2);
+	}
+	else
+	{
+		return head_match && isMatch(s + 1, p + 1);
+	}
+}
\ No newline at end of file

data_source/1.leetcode/10-正则表达式匹配/solution.json

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

data_source/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
+#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));
+    }
+};
+```

data_source/1.leetcode/100-相同的树/config.json

+{
+  "node_id": "algorithm-683ff2c7575845ceb42a4d068f379e5d",
+  "keywords": [
+    "leetcode",
+    "相同的树"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/100-相同的树/desc.html

+<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>
\ No newline at end of file

data_source/1.leetcode/100-相同的树/solution.cpp

+#include <bits/stdc++.h>
+using namespace std;
+struct TreeNode
+{
+	int val;
+	TreeNode *left;
+	TreeNode *right;
+	TreeNode() : val(0), left(nullptr), right(nullptr) {}
+	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+	TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+class Solution
+{
+public:
+	bool isSameTree(TreeNode *p, TreeNode *q)
+	{
+		if (p == nullptr && q == nullptr)
+		{
+			return true;
+		}
+		if (p == nullptr || q == nullptr)
+		{
+			return false;
+		}
+		if (p->val != q->val)
+		{
+			return false;
+		}
+		return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+	}
+};
\ No newline at end of file

data_source/1.leetcode/100-相同的树/solution.json

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

data_source/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
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode() : val(0), left(nullptr), right(nullptr) {}
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+
+```
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+都是错的
+```
+
+## 选项
+
+
+### A
+
+```cpp
+class Solution
+{
+public:
+    bool isSameTree(TreeNode *p, TreeNode *q)
+    {
+        if (p == nullptr)
+            return q == nullptr;
+        return q != nullptr && p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
+    }
+};
+```
+
+### B
+
+```cpp
+class Solution
+{
+public:
+    bool isSameTree(TreeNode *p, TreeNode *q)
+    {
+        TreeNode *temp, *temq;
+        temp = p;
+        temq = q;
+        bool lb, rb;
+        if (!p && !q)
+            return true;
+        if ((!p || !q) || p->val != q->val)
+            return false;
+        else
+        {
+            lb = isSameTree(p->left, q->left);
+            rb = isSameTree(p->right, q->right);
+        }
+        if (lb && rb)
+            return true;
+        else
+            return false;
+    }
+};
+```
+
+### C
+
+```cpp
+class Solution
+{
+public:
+    bool isSameTree(TreeNode *p, TreeNode *q)
+    {
+        if (p == NULL && q == NULL)
+            return true;
+        if (p == NULL || q == NULL)
+            return false;
+        if (p->val != q->val)
+            return false;
+        return (isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
+    }
+};
+```

data_source/1.leetcode/1000-合并石头的最低成本/config.json

+{
+  "node_id": "algorithm-883ab3afc34c4c19a14ed59ce1539498",
+  "keywords": [
+    "leetcode",
+    "合并石头的最低成本"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1000-合并石头的最低成本/desc.html

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

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

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

data_source/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_source/1.leetcode/1001-网格照明/config.json

+{
+  "node_id": "algorithm-e1bb03e3274f43b7bd79f025ad82c47d",
+  "keywords": [
+    "leetcode",
+    "网格照明"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1001-网格照明/desc.html

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

data_source/1.leetcode/1001-网格照明/solution.json

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

data_source/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_source/1.leetcode/1002-查找常用字符/config.json

+{
+  "node_id": "algorithm-41bc5cb7d82f41c482326005e8e1d0de",
+  "keywords": [
+    "leetcode",
+    "查找常用字符"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1002-查找常用字符/desc.html

+给你一个字符串数组 <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>

data_source/1.leetcode/1002-查找常用字符/solution.json

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

data_source/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_source/1.leetcode/1003-检查替换后的词是否有效/config.json

+{
+  "node_id": "algorithm-5d915b752a214094b93383929f347c87",
+  "keywords": [
+    "leetcode",
+    "检查替换后的词是否有效"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1003-检查替换后的词是否有效/desc.html

+给你一个字符串 <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>

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

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

data_source/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_source/1.leetcode/1004-最大连续1的个数 III/config.json

+{
+  "node_id": "algorithm-fd9fd4b5389d44f5a67bb0a8e7122285",
+  "keywords": [
+    "leetcode",
+    "最大连续1的个数 III"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1004-最大连续1的个数 III/desc.html

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

data_source/1.leetcode/1004-最大连续1的个数 III/solution.json

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

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

+# 最大连续1的个数 III
+
+<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_source/1.leetcode/1005-K 次取反后最大化的数组和/config.json

+{
+  "node_id": "algorithm-af596c538c1d4466b3e73e4782c808e4",
+  "keywords": [
+    "leetcode",
+    "K 次取反后最大化的数组和"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1005-K 次取反后最大化的数组和/desc.html

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

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

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

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

+# K 次取反后最大化的数组和
+
+<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_source/1.leetcode/1006-笨阶乘/config.json

+{
+  "node_id": "algorithm-41afa97921214a1289972fbc404bac0c",
+  "keywords": [
+    "leetcode",
+    "笨阶乘"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1006-笨阶乘/desc.html

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

data_source/1.leetcode/1006-笨阶乘/solution.json

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

data_source/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_source/1.leetcode/1007-行相等的最少多米诺旋转/config.json

+{
+  "node_id": "algorithm-8f5c157327a44f958433ff8129fcaf29",
+  "keywords": [
+    "leetcode",
+    "行相等的最少多米诺旋转"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1007-行相等的最少多米诺旋转/desc.html

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

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

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

data_source/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_source/1.leetcode/1008-前序遍历构造二叉搜索树/config.json

+{
+  "node_id": "algorithm-ebba59d3bc9a49f98f9707934ec2e860",
+  "keywords": [
+    "leetcode",
+    "前序遍历构造二叉搜索树"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1008-前序遍历构造二叉搜索树/desc.html

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

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

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

data_source/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_source/1.leetcode/1009-十进制整数的反码/config.json

+{
+  "node_id": "algorithm-d85f606f8d6d422ebe1fc4ee6184bce2",
+  "keywords": [
+    "leetcode",
+    "十进制整数的反码"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1009-十进制整数的反码/desc.html

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

data_source/1.leetcode/1009-十进制整数的反码/solution.json

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

data_source/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_source/1.leetcode/101-对称二叉树/config.json

+{
+  "node_id": "algorithm-587f3b68dc7047d5b2445cb0c5fc50c3",
+  "keywords": [
+    "leetcode",
+    "对称二叉树"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/101-对称二叉树/desc.html

+<p>给定一个二叉树，检查它是否是镜像对称的。</p>
+
+<p>&nbsp;</p>
+
+<p>例如，二叉树&nbsp;<code>[1,2,2,3,4,4,3]</code> 是对称的。</p>
+
+<pre>    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
+</pre>
+
+<p>&nbsp;</p>
+
+<p>但是下面这个&nbsp;<code>[1,2,2,null,3,null,3]</code> 则不是镜像对称的:</p>
+
+<pre>    1
+   / \
+  2   2
+   \   \
+   3    3
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>进阶：</strong></p>
+
+<p>你可以运用递归和迭代两种方法解决这个问题吗？</p>

data_source/1.leetcode/101-对称二叉树/solution.cpp

+#include <cstddef>
+#include <stack>
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    bool isSymmetric(TreeNode *root)
+    {
+        if (root == NULL)
+            return true;
+        TreeNode *lt = root->left, *rt = root->right;
+        for (std::stack<TreeNode *> stack; !stack.empty() || (lt && rt);)
+        {
+            if (lt && rt)
+            {
+                if (lt->val != rt->val)
+                    return false;
+                stack.push(lt->right);
+                stack.push(rt->left);
+                lt = lt->left;
+                rt = rt->right;
+            }
+            else if (lt || rt)
+                return false;
+            else
+            {
+                lt = stack.top();
+                stack.pop();
+                rt = stack.top();
+                stack.pop();
+            }
+        }
+        if (lt || rt)
+            return false;
+        else
+            return true;
+    }
+};
\ No newline at end of file

data_source/1.leetcode/101-对称二叉树/solution.json

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

data_source/1.leetcode/101-对称二叉树/solution.md

+# 对称二叉树
+
+<p>给定一个二叉树，检查它是否是镜像对称的。</p>
+
+<p>&nbsp;</p>
+
+<p>例如，二叉树&nbsp;<code>[1,2,2,3,4,4,3]</code> 是对称的。</p>
+
+<pre>    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
+</pre>
+
+<p>&nbsp;</p>
+
+<p>但是下面这个&nbsp;<code>[1,2,2,null,3,null,3]</code> 则不是镜像对称的:</p>
+
+<pre>    1
+   / \
+  2   2
+   \   \
+   3    3
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>进阶：</strong></p>
+
+<p>你可以运用递归和迭代两种方法解决这个问题吗？</p>
+
+<p>以下错误的选项是？</p>
+
+## aop
+
+### before
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode() : val(0), left(nullptr), right(nullptr) {}
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+```
+### after
+
+```cpp
+
+```
+
+## 答案
+
+```cpp
+class Solution
+{
+public:
+    bool isSymmetric(TreeNode *root)
+    {
+        if (!root)
+            return true;
+        queue<TreeNode *> q;
+        q.push(root->left);
+        q.push(root->right);
+        while (!q.empty())
+        {
+            auto p1 = q.front();
+            q.pop();
+            auto p2 = q.front();
+            q.pop();
+            if (!p1 && !p2)
+                continue;
+            if (!p1 || !p2)
+                return false;
+            if (p1->val != p2->val)
+                return false;
+            q.push(p1->right);
+            q.push(p1->left);
+            q.push(p2->right);
+            q.push(p2->left);
+        }
+        return true;
+    }
+};
+
+```
+
+## 选项
+
+
+### A
+
+```cpp
+class Solution
+{
+public:
+    bool isSymmetric(TreeNode *root)
+    {
+        queue<TreeNode *> q1, q2;
+        if (!root)
+            return true;
+        q1.push(root->left);
+        q2.push(root->right);
+        while (!q1.empty() && !q2.empty())
+        {
+            TreeNode *node1 = q1.front();
+            q1.pop();
+            TreeNode *node2 = q2.front();
+            q2.pop();
+            if (!node1 && !node2)
+                continue;
+            if ((!node1 && node2) || (node1 && !node2) || (node1->val != node2->val))
+                return false;
+            q1.push(node1->left);
+            q1.push(node1->right);
+            q2.push(node2->right);
+            q2.push(node2->left);
+        }
+        return true;
+    }
+};
+```
+
+### B
+
+```cpp
+class Solution
+{
+public:
+    bool isSymmetric(TreeNode *root)
+    {
+        if (!root)
+            return true;
+        return helper(root->left, root->right);
+    }
+    bool helper(TreeNode *left, TreeNode *right)
+    {
+        if (!left && !right)
+            return true;
+        if ((!left && right) || (left && !right) || (left->val != right->val))
+            return false;
+        return helper(left->left, right->right) && helper(left->right, right->left);
+    }
+};
+```
+
+### C
+
+```cpp
+class Solution
+{
+public:
+    bool isSymmetric(TreeNode *root)
+    {
+        return ismirror(root, root);
+    }
+    bool ismirror(TreeNode *t1, TreeNode *t2)
+    {
+        if (t1 == NULL && t2 == NULL)
+            return true;
+        if (t1 == NULL || t2 == NULL)
+            return false;
+        return (t1->val == t2->val) && ismirror(t1->left, t2->right) && ismirror(t1->right, t2->left);
+    }
+};
+```

data_source/1.leetcode/1010-总持续时间可被 60 整除的歌曲/config.json

+{
+  "node_id": "algorithm-f7c286d9ef6b400185f2f8447cac3596",
+  "keywords": [
+    "leetcode",
+    "总持续时间可被 60 整除的歌曲"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1010-总持续时间可被 60 整除的歌曲/desc.html

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

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

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

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

+# 总持续时间可被 60 整除的歌曲
+
+<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_source/1.leetcode/1011-在 D 天内送达包裹的能力/config.json

+{
+  "node_id": "algorithm-2a995cc9fa344d029c0c86d0bd298e24",
+  "keywords": [
+    "leetcode",
+    "在 D 天内送达包裹的能力"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1011-在 D 天内送达包裹的能力/desc.html

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

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

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

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

+# 在 D 天内送达包裹的能力
+
+<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_source/1.leetcode/1012-至少有 1 位重复的数字/config.json

+{
+  "node_id": "algorithm-92593c50a48844559a4145b0195e3265",
+  "keywords": [
+    "leetcode",
+    "至少有 1 位重复的数字"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1012-至少有 1 位重复的数字/desc.html

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

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

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

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

+# 至少有 1 位重复的数字
+
+<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_source/1.leetcode/1013-将数组分成和相等的三个部分/config.json

+{
+  "node_id": "algorithm-b671321fbbc94fae92f034f65238033e",
+  "keywords": [
+    "leetcode",
+    "将数组分成和相等的三个部分"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1013-将数组分成和相等的三个部分/desc.html

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

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

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

data_source/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_source/1.leetcode/1014-最佳观光组合/config.json

+{
+  "node_id": "algorithm-184f636d8c5f4c31b43c9e21fd21ec4e",
+  "keywords": [
+    "leetcode",
+    "最佳观光组合"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1014-最佳观光组合/desc.html

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

data_source/1.leetcode/1014-最佳观光组合/solution.json

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

data_source/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_source/1.leetcode/1015-可被 K 整除的最小整数/config.json

+{
+  "node_id": "algorithm-de1bf2fc0fec4752ad7e682602d84733",
+  "keywords": [
+    "leetcode",
+    "可被 K 整除的最小整数"
+  ],
+  "children": [],
+  "export": [
+    "solution.json"
+  ]
+}
\ No newline at end of file

data_source/1.leetcode/1015-可被 K 整除的最小整数/desc.html

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

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

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