add 10 exercises for leetcode

data/3.算法高阶/1.leetcode/52_最大子序和/solution.md

+# 最大子序和
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    vector<int> nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
+    int res;
+
+    res = sol.maxSubArray(nums);
+    cout << res;
+    return 0;
+}
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    int maxSubArray(vector<int> &nums)
+    {
+        if (nums.empty())
+            return 0;
+        int pre = 0, res = nums[0];
+        for (auto c : nums)
+        {
+            pre = max(pre, c);
+            res = max(pre, res);
+        }
+        return res;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    int maxSubArray(vector<int> &nums)
+    {
+        int sum = 0, max_sum = INT_MIN;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (sum < 0)
+            {
+                sum = nums[i];
+            }
+            else
+            {
+                sum += nums[i];
+            }
+            max_sum = max(sum, max_sum);
+        }
+        return max_sum;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    int maxSubArray(vector<int> &nums)
+    {
+        if (nums.size() == 0)
+            return NULL;
+        return fenzhifa(nums, 0, nums.size() - 1);
+    }
+    int fenzhifa(vector<int> &nums, int left, int right)
+    {
+        if (left > right)
+            return INT_MIN;
+        if (left == right)
+            return nums[left];
+        int mid = (left + right) / 2;
+        int l = fenzhifa(nums, 0, mid - 1);
+        int r = fenzhifa(nums, mid + 1, right);
+        int t = nums[mid];
+        int max_num = nums[mid];
+        for (int i = mid - 1; i >= left; i--)
+        {
+            t += nums[i];
+            max_num = max(max_num, t);
+        }
+        t = max_num;
+        for (int i = mid + 1; i <= right; i++)
+        {
+            t += nums[i];
+            max_num = max(max_num, t);
+        }
+        return max(max(r, l), max_num);
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    int maxSubArray(vector<int> &nums)
+    {
+        int maxsum = nums[0];
+        for (int i = 0; i < nums.size(); i++)
+        {
+            int sum = 0;
+            for (int j = i; j < nums.size(); j++)
+            {
+                sum = sum + nums[j];
+                if (maxsum < sum)
+                    maxsum = sum;
+            }
+        }
+        return maxsum;
+    }
+};
+```

data/3.算法高阶/1.leetcode/53_螺旋矩阵/solution.md

+# 螺旋矩阵
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    vector<int> printMatrix(vector<vector<int>> matrix)
+    {
+        vector<int> res;
+        if (matrix.size() == 0)
+            return res;
+        int r1 = 0, r2 = matrix.size() - 1;
+        int c1 = 0, c2 = matrix[0].size() - 1;
+        int i = 0, j = 0;
+        int sum = matrix.size() * matrix[0].size();
+        while (res.size() < sum)
+        {
+            if (j == c1 && i == r1)
+            {
+                while (j <= c2)
+                    res.push_back(matrix[i][j++]);
+                ++r1;
+                --j;
+                ++i;
+            }
+            else if (j == c2 && i == r1)
+            {
+                while (i <= r2)
+                    res.push_back(matrix[i++][j]);
+                ++c2;
+                --i;
+                --j;
+            }
+            else if (j == c2 && i == r2)
+            {
+                while (j >= c1)
+                    res.push_back(matrix[i][j--]);
+                --r2;
+                ++j;
+                --i;
+            }
+            else
+            {
+                while (i >= r1)
+                    res.push_back(matrix[i--][j]);
+                ++c1;
+                ++i;
+                ++j;
+            }
+        }
+        return res;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    vector<int> spiralOrder(vector<vector<int>> &matrix)
+    {
+        vector<int> res;
+        int hor_top = 0;
+        int hor_bottom = matrix.size() - 1;
+        int ver_left = 0;
+        int ver_right = matrix[0].size() - 1;
+        int direction = 0;
+        while (hor_top <= hor_bottom && ver_left <= ver_right)
+        {
+            switch (direction)
+            {
+            case 0:
+                for (int i = ver_left; i <= ver_right; i++)
+                {
+                    res.push_back(matrix[hor_top][i]);
+                }
+                hor_top++;
+                break;
+            case 1:
+                for (int i = hor_top; i <= hor_bottom; i++)
+                {
+                    res.push_back(matrix[i][ver_right]);
+                }
+                ver_right--;
+                break;
+            case 2:
+                for (int i = ver_right; i >= ver_left; i--)
+                {
+                    res.push_back(matrix[hor_bottom][i]);
+                }
+                hor_bottom--;
+                break;
+            case 3:
+                for (int i = hor_bottom; i >= hor_top; i--)
+                {
+                    res.push_back(matrix[i][ver_left]);
+                }
+                ver_left++;
+                break;
+            default:
+                break;
+            }
+            direction++;
+            direction %= 4;
+        }
+        return res;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    vector<int> spiralOrder(vector<vector<int>> &matrix)
+    {
+        vector<int> res;
+        if (matrix.size() == 0)
+            return res;
+        int up = 0, down = matrix.size() - 1, left = 0, right = matrix[0].size() - 1;
+        while (up <= down && left <= right)
+        {
+            for (int i = left; i <= right; i++)
+                res.push_back(matrix[up][i]);
+            for (int i = up + 1; i <= down; i++)
+                res.push_back(matrix[i][right]);
+            if (up < down && left < right)
+            {
+                for (int i = right - 1; i > left; i--)
+                    res.push_back(matrix[down][i]);
+                for (int i = down; i > up; i--)
+                    res.push_back(matrix[i][left]);
+            }
+            up++;
+            down--;
+            left++;
+            right--;
+        }
+        return res;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    vector<int> spiralOrder(vector<vector<int>> &matrix)
+    {
+        vector<int> path;
+        if (matrix.empty())
+            return path;
+        int rows = matrix.size(), cols = matrix[0].size();
+        int top = 0, bottom = rows - 1, left = 0, right = cols - 1;
+        while (true)
+        {
+            for (int col = left; col <= right; ++col)
+                path.push_back(matrix[top][col]);
+            ++top;
+            if (top > bottom)
+                break;
+
+            for (int row = top; row <= bottom; ++row)
+                path.push_back(matrix[row][right]);
+            --right;
+            if (right < left)
+                break;
+
+            for (int col = right; col >= left; --col)
+                path.push_back(matrix[bottom][col]);
+            --bottom;
+            if (top > bottom)
+                break;
+
+            for (int row = bottom; row >= top; --row)
+                path.push_back(matrix[row][left]);
+            ++left;
+            if (right < left)
+                break;
+        }
+        return path;
+    }
+};
+```

data/3.算法高阶/1.leetcode/54_跳跃游戏/solution.md

+# 跳跃游戏
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    vector<int> nums = {2, 3, 1, 1, 4};
+    bool res;
+
+    res = sol.canJump(nums);
+    cout << res;
+    return 0;
+}
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    bool canJump(vector<int> &nums)
+    {
+        int maxPosi = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (maxPosi < i)
+                return false;
+            maxPosi = max(maxPosi, nums[i]);
+        }
+        return true;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    bool canJump(vector<int> &nums)
+    {
+        int maxPosi = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (maxPosi < i)
+                return false;
+            if (maxPosi < i + nums[i])
+                maxPosi = i + nums[i];
+        }
+        return true;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    bool canJump(vector<int> &nums)
+    {
+        int right_most = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            if (i <= right_most)
+            {
+                right_most = max(right_most, nums[i] + i);
+                if (right_most >= nums.size() - 1)
+                    return true;
+            }
+        }
+        return false;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    bool canJump(vector<int> &nums)
+    {
+        int i = 0, j = 1, n = nums.size();
+        while (j < n)
+        {
+            int end = min(nums[i] + i + 1, n);
+            if (nums[i] == 0)
+                return false;
+            while (j < end)
+            {
+                if (nums[j] + j >= nums[i] + i)
+                    i = j;
+                j++;
+            }
+            if (nums[i] + i > n)
+                break;
+        }
+        return true;
+    }
+};
+```

data/3.算法高阶/1.leetcode/55_合并区间/solution.md

+# 合并区间
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> merge(vector<vector<int>> &intervals)
+    {
+        vector<vector<int>> res;
+        sort(intervals.begin(), intervals.end(), [](const auto &u, const auto &v)
+             {
+                 if (u[0] == v[0])
+                     return u[1] > v[1];
+                 else
+                     return u[0] < v[0];
+             });
+        auto it = intervals.begin();
+        int first = (*it)[0], second = (*it)[1];
+        for (it++; it != intervals.end(); it++)
+        {
+            if ((*it)[0] <= second)
+                second = max(second, (*it)[0]);
+            else
+            {
+                res.push_back({first, second});
+                first = (*it)[0];
+                second = (*it)[1];
+            }
+        }
+        res.push_back({first, second});
+        return res;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> merge(vector<vector<int>> &intervals)
+    {
+        vector<vector<int>> res;
+        sort(intervals.begin(), intervals.end());
+        for (auto it = intervals.begin(); it != intervals.end(); it++)
+        {
+            int first = (*it)[0], second = (*it)[1];
+            if (!res.size() || res.back()[1] < first)
+                res.push_back({first, second});
+            else
+                res.back()[1] = max(res.back()[1], second);
+        }
+        return res;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> merge(vector<vector<int>> &intervals)
+    {
+        sort(intervals.begin(), intervals.end());
+        vector<vector<int>> res;
+        for (int i = 0; i < intervals.size();)
+        {
+            int t = intervals[i][1];
+            int j = i + 1;
+            while (j < intervals.size() && intervals[j][0] <= t)
+            {
+                t = max(t, intervals[j][1]);
+                j++;
+            }
+            res.push_back({intervals[i][0], t});
+            i = j;
+        }
+        return res;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    static bool cmp(const vector<int> &a, const vector<int> &b)
+    {
+        if (a[0] == b[0])
+            return a[1] > b[1];
+        return a[0] < b[0];
+    }
+    vector<vector<int>> merge(vector<vector<int>> &intervals)
+    {
+        if (intervals.empty())
+            return intervals;
+        vector<vector<int>> res;
+        int count = 0;
+        sort(intervals.begin(), intervals.end(), cmp);
+        vector<int> temp;
+        temp.push_back(intervals[0][0]);
+        temp.push_back(intervals[0][1]);
+        res.push_back(temp);
+        for (int i = 1; i < intervals.size(); i++)
+        {
+            if (res[count][1] >= intervals[i][0])
+            {
+                if (res[count][1] <= intervals[i][1])
+                {
+                    res[count][1] = intervals[i][1];
+                }
+            }
+            else
+            {
+                count++;
+                temp[0] = intervals[i][0];
+                temp[1] = intervals[i][1];
+                res.push_back(temp);
+            }
+        }
+        return res;
+    }
+};
+```

data/3.算法高阶/1.leetcode/56_插入区间/solution.md

+# 插入区间
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> insert(vector<vector<int>> &intervals, vector<int> &newInterval)
+    {
+        intervals.push_back(newInterval);
+        sort(intervals.begin(), intervals.end());
+        int n = intervals.size();
+        vector<vector<int>> ans;
+        for (int i = 0; i < n; i++)
+        {
+            int l = intervals[i][0], r = intervals[i][1];
+            if (!ans.size())
+                ans.push_back({l, r});
+            else
+                ans.back()[1] = max(ans.back()[1], r);
+        }
+        return ans;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> insert(vector<vector<int>> &intervals, vector<int> &newInterval)
+    {
+        if (intervals.size() == 0)
+            return {newInterval};
+        vector<vector<int>> res;
+        int lpos = 0, rpos = 0;
+        for (int i = 0; i < intervals.size(); i++)
+        {
+            if (intervals[i][0] < newInterval[0])
+                lpos++;
+            if (intervals[i][1] < newInterval[1])
+                rpos++;
+        }
+        if (lpos > rpos)
+        {
+            return intervals;
+        }
+        if (rpos == 0)
+        {
+            if (intervals[rpos][0] > newInterval[1])
+            {
+                res.push_back(newInterval);
+                for (int i = 0; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+            else
+            {
+                res.push_back({newInterval[0], intervals[0][1]});
+                for (int i = 1; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+        }
+        else if (lpos == 0)
+        {
+            if (rpos == intervals.size())
+            {
+                res.push_back(newInterval);
+            }
+            else if (intervals[rpos][0] > newInterval[1])
+            {
+                res.push_back(newInterval);
+                for (int i = rpos; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+            else if (intervals[rpos][0] <= newInterval[1])
+            {
+                res.push_back({newInterval[0], intervals[rpos][1]});
+                for (int i = rpos + 1; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+        }
+        else
+        {
+            if (intervals[lpos - 1][1] >= newInterval[0] && rpos == intervals.size())
+            {
+                for (int i = 0; i < lpos - 1; i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+                res.push_back({intervals[lpos - 1][0], newInterval[1]});
+            }
+            else if (intervals[lpos - 1][1] < newInterval[0] && rpos == intervals.size())
+            {
+                for (int i = 0; i < lpos; i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+                res.push_back(newInterval);
+            }
+            else if (intervals[lpos - 1][1] >= newInterval[0] && intervals[rpos][0] <= newInterval[1])
+            {
+                for (int i = 0; i < lpos - 1; i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+                res.push_back({intervals[lpos - 1][0], intervals[rpos][1]});
+                for (int i = rpos + 1; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+            else if (intervals[lpos - 1][1] >= newInterval[0] && intervals[rpos][0] > newInterval[1])
+            {
+                for (int i = 0; i < lpos - 1; i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+                res.push_back({intervals[lpos - 1][0], newInterval[1]});
+                for (int i = rpos; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+            else if (intervals[lpos - 1][1] < newInterval[0] && intervals[rpos][0] > newInterval[1])
+            {
+                for (int i = 0; i <= lpos - 1; i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+                res.push_back({newInterval[0], newInterval[1]});
+                for (int i = rpos; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+            else if (intervals[lpos - 1][1] < newInterval[0] && intervals[rpos][0] <= newInterval[1])
+            {
+                for (int i = 0; i <= lpos - 1; i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+                res.push_back({newInterval[0], intervals[rpos][1]});
+                for (int i = rpos + 1; i < intervals.size(); i++)
+                {
+                    res.push_back(intervals[i]);
+                }
+            }
+        }
+        return res;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> insert(vector<vector<int>> &intervals, vector<int> &newInterval)
+    {
+        if (newInterval.empty())
+            return intervals;
+        else if (intervals.empty())
+        {
+            intervals.push_back(newInterval);
+            return intervals;
+        }
+        vector<vector<int>> res;
+        int i = 0;
+        while (i < intervals.size() && intervals[i][1] < newInterval[0])
+        {
+            res.push_back(intervals[i]);
+            i++;
+        }
+        while (i < intervals.size() && intervals[i][0] <= newInterval[1])
+        {
+            newInterval[0] = min(intervals[i][0], newInterval[0]);
+            newInterval[1] = max(intervals[i][1], newInterval[1]);
+            i++;
+        }
+        res.push_back(newInterval);
+        while (i < intervals.size())
+        {
+            res.push_back(intervals[i]);
+            i++;
+        }
+        return res;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> insert(vector<vector<int>> &intervals, vector<int> &newInterval)
+    {
+        if (intervals.empty())
+        {
+            intervals.push_back(newInterval);
+            return intervals;
+        }
+        int n = intervals.size();
+        int i = 0, j = n - 1;
+        vector<vector<int>> ans;
+        for (i = 0; i < n; i++)
+            if (newInterval[0] <= intervals[i][1])
+                break;
+        for (j = n - 1; j >= 0; j--)
+            if (newInterval[1] >= intervals[j][0])
+                break;
+        if (i == n)
+            intervals.push_back(newInterval);
+        else if (j == -1)
+            intervals.insert(intervals.begin(), newInterval);
+        else if (i > j)
+        {
+            intervals.insert(intervals.begin() + i, newInterval);
+        }
+        else if (i == j)
+        {
+            intervals[i][0] = min(intervals[i][0], newInterval[0]);
+            intervals[i][1] = max(intervals[i][1], newInterval[1]);
+        }
+        else
+        {
+            int minN = min(intervals[i][0], newInterval[0]);
+            int maxN = max(intervals[j][1], newInterval[1]);
+            intervals.erase(intervals.begin() + i, intervals.begin() + j + 1);
+            intervals.insert(intervals.begin() + i, {minN, maxN});
+        }
+
+        return intervals;
+    }
+};
+```

data/3.算法高阶/1.leetcode/57_最后一个单词的长度/solution.md

+# 最后一个单词的长度
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    string s = "Hello World";
+    int res;
+
+    res = sol.lengthOfLastWord(s);
+    cout << res;
+    return 0;
+}
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    int lengthOfLastWord(string s)
+    {
+        if (s.empty())
+            return 0;
+        int pos = s.find_last_of(' ');
+        while (pos == s.length() - 1)
+        {
+            if (s.empty())
+                return 0;
+            s.erase(pos);
+            pos = s.find_last_of(' ');
+        }
+        return s.length() - pos;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    int lengthOfLastWord(string s)
+    {
+        string word;
+        stringstream ss(s);
+        while (ss >> word)
+        {
+        }
+        return word.size();
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    int lengthOfLastWord(string s)
+    {
+        int countWord = 0;
+        for (int index = 0; index < s.size(); index++)
+        {
+            if (s[index] == ' ')
+            {
+                if (index != s.size() - 1 && s[index + 1] != ' ')
+                {
+                    countWord = 0;
+                    continue;
+                }
+                else
+                    continue;
+            }
+            countWord++;
+        }
+        return countWord;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    int lengthOfLastWord(string s)
+    {
+        if (s.empty())
+            return 0;
+        vector<string> word;
+        int begin, lenWord = 0;
+        for (int i = 0; i < s.size(); i++)
+        {
+            if ((i == 0 && s[i] != ' ') || (i != 0 && s[i - 1] == ' ' && s[i] != ' '))
+            {
+                begin = i;
+                lenWord++;
+                if (i == s.size() - 1)
+                {
+                    word.push_back(s.substr(begin, lenWord));
+                    break;
+                }
+            }
+            else if (s[i] != ' ' && i != s.size() - 1)
+            {
+                lenWord++;
+            }
+            else if (i != 0 && s[i - 1] != ' ' && s[i] == ' ')
+            {
+                word.push_back(s.substr(begin, lenWord));
+                lenWord = 0;
+            }
+            else if (s[i] != ' ' && i == s.size() - 1)
+            {
+                word.push_back(s.substr(begin, lenWord + 1));
+            }
+        }
+        if (word.empty())
+            return 0;
+        else
+            return word[word.size() - 1].size();
+    }
+};
+```

data/3.算法高阶/1.leetcode/58_螺旋矩阵 II/solution.md

+# 螺旋矩阵 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    int n = 3;
+    vector<vector<int>> res;
+
+    res = sol.generateMatrix(n);
+    for (auto i : res)
+    {
+        for (auto j : i)
+            cout << j << " ";
+        cout << endl;
+    }
+    return 0;
+}
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> generateMatrix(int n)
+    {
+        vector<vector<int>> ans(n, vector<int>(n, 0));
+        int c = n / 2;
+        int val = 1;
+        for (int i = 0; i < c; ++i, n -= 2)
+        {
+            for (int col = i; col < i + n; ++col)
+                ans[i][col] = val++;
+            if (n == 1)
+                return ans;
+            for (int row = i + 1; row < i + n; ++row)
+                ans[row][i + n - 1] = val++;
+            for (int col = i + n - 2; col >= i; --col)
+                ans[i + n - 1][col] = val++;
+            for (int row = i + n - 2; row > i; --row)
+                ans[row][i] = val++;
+        }
+        return ans;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+
+class Solution
+{
+public:
+    vector<vector<int>> generateMatrix(int n)
+    {
+
+        vector<vector<int>> matrix(n, vector<int>(n));
+        int u = 0, d = n - 1, l = 0, r = n - 1, k = 0;
+
+        while (true)
+        {
+
+            for (int col = l; col <= r; col++)
+                matrix[u][col] = ++k;
+            if (++u > d)
+                break;
+
+            for (int row = u; row <= d; row++)
+                matrix[row][r] = ++k;
+            if (--r < l)
+                break;
+
+            for (int col = r; col >= l; col--)
+                matrix[d][col] = ++k;
+            if (--d < u)
+                break;
+
+            for (int row = d; row >= u; row--)
+                matrix[row][l] = ++k;
+            if (++l > r)
+                break;
+        }
+        return matrix;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> generateMatrix(int n)
+    {
+        vector<vector<int>> result(n, vector<int>(n, 0));
+
+        int top = 0, right = n - 1, left = 0, bottom = n - 1;
+        int k = 1;
+        while (k <= n * n)
+        {
+            for (int i = left; i <= right; i++)
+                result[top][i] = k++;
+            top++;
+            for (int i = top; i <= bottom; i++)
+                result[i][right] = k++;
+            right--;
+            for (int i = right; i >= left; i--)
+                result[bottom][i] = k++;
+            bottom--;
+            for (int i = bottom; i >= top; i--)
+                result[i][left] = k++;
+            left++;
+        }
+        return result;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    vector<vector<int>> generateMatrix(int n)
+    {
+        vector<vector<int>> matrix(n, vector<int>(n));
+        int direction = 0;
+        int hor_top = 0;
+        int hor_bottom = n - 1;
+        int ver_left = 0;
+        int ver_right = n - 1;
+        int num = 0;
+        while (num < n * n)
+        {
+            switch (direction)
+            {
+            case 0:
+                for (int i = ver_left; i <= ver_right; i++)
+                {
+                    matrix[hor_top][i] = ++num;
+                }
+                hor_top++;
+                break;
+            case 1:
+                for (int i = hor_top; i <= hor_bottom; i++)
+                {
+                    matrix[i][ver_right] = ++num;
+                }
+                ver_right--;
+                break;
+            case 2:
+                for (int i = ver_right; i >= ver_left; i--)
+                {
+                    matrix[hor_bottom][i] = ++num;
+                }
+                hor_bottom--;
+                break;
+            case 3:
+                for (int i = hor_bottom; i >= hor_top; i--)
+                {
+                    matrix[i][ver_left] = ++num;
+                }
+                ver_left++;
+                break;
+            }
+            direction++;
+            direction %= 4;
+        }
+        return matrix;
+    }
+};
+```

data/3.算法高阶/1.leetcode/59_排列序列/solution.md

+# 排列序列
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    int n = 3;
+    int k = 3;
+    string res;
+
+    res = sol.getPermutation(n, k);
+    cout << res;
+    return 0;
+}
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    string getPermutation(int n, int k)
+    {
+        string res;
+        vector<int> candidates;
+
+        vector<int> factorial(n + 1);
+        factorial[0] = 1;
+        int fact = 1;
+        for (int i = 1; i <= n; i++)
+        {
+            candidates.push_back(i);
+            fact *= i;
+            factorial[i] = fact;
+        }
+        k -= 1;
+        for (int i = n - 1; i >= 0; i--)
+        {
+            int index = k / factorial[i];
+            k = index * factorial[i];
+            res.push_back(candidates[index] + '0');
+            candidates.erase(candidates.begin() + index);
+        }
+        return res;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+
+class Solution
+{
+public:
+    vector<string> res;
+    string getPermutation(int n, int k)
+    {
+        string track;
+        traverse(track, n);
+        return res[k - 1];
+    }
+    void traverse(string &track, int n)
+    {
+
+        if (track.size() == n)
+        {
+            res.push_back(track);
+            return;
+        }
+        for (int i = 1; i <= n; i++)
+        {
+            char c = i + '0';
+            if (find(track.begin(), track.end(), c) != track.end())
+                continue;
+
+            track.push_back(c);
+            traverse(track, n);
+            track.pop_back();
+        }
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    string getPermutation(int n, int k)
+    {
+        string ans;
+
+        vector<bool> st(n + 1);
+
+        for (int i = 1; i <= n; i++)
+        {
+
+            int f = 1;
+
+            for (int j = n - i; j >= 1; j--)
+                f *= j;
+
+            for (int j = 1; j <= n; j++)
+            {
+
+                if (!st[j])
+                {
+
+                    if (k <= f)
+                    {
+                        ans += to_string(j);
+                        st[j] = 1;
+                        break;
+                    }
+
+                    k -= f;
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    int th;
+    string ans;
+    string getPermutation(int n, int k)
+    {
+        string s;
+        vector<bool> vec(9, false);
+        this->th = 0;
+
+        backtrack(n, k, s, vec);
+
+        return ans;
+    }
+
+    bool backtrack(int n, int k, string &s, vector<bool> &vec)
+    {
+
+        if (s.length() == n)
+        {
+            if (++th == k)
+            {
+                ans = s;
+                return true;
+            }
+        }
+
+        for (char c = '1'; c <= '1' + n - 1; c++)
+        {
+
+            if (vec[c - '1'])
+                continue;
+
+            s.push_back(c);
+            vec[c - '1'] = true;
+
+            if (backtrack(n, k, s, vec))
+                return true;
+
+            s.pop_back();
+            vec[c - '1'] = false;
+        }
+        return false;
+    }
+};
+```

data/3.算法高阶/1.leetcode/60_旋转链表/solution.md

+# 旋转链表
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    ListNode *rotateRight(ListNode *head, int k)
+    {
+        if (!head || !head->next || k == 0)
+            return head;
+        int len = 1;
+        ListNode *cur = head;
+        while (cur->next && ++len)
+            cur = cur->next;
+        cur->next = head;
+        k = (len - k) % len;
+        while (k--)
+            cur = cur->next;
+        head = cur->next;
+        cur->next = nullptr;
+        return head;
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    ListNode *rotateRight(ListNode *head, int k)
+    {
+        if (k == 0 || !head || !(head->next))
+            return head;
+        ListNode *temp = head;
+        int len = 0;
+        while (temp)
+        {
+            ++len;
+            temp = temp->next;
+        }
+        k = k % len;
+        temp = head;
+        for (int i = len - 1; i > 0; --i)
+            temp = temp->next;
+        temp->next = head;
+        temp = head;
+        for (int j = len - k; j > 0; --j)
+            temp = temp->next;
+        head = temp;
+        for (int m = len - 1; m > 0; --m)
+            temp = temp->next;
+        temp->next = nullptr;
+        return head;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    ListNode *rotateRight(ListNode *head, int k)
+    {
+        if (head == NULL)
+            return head;
+        ListNode *p = head;
+        ListNode *q = head;
+        int len = 1;
+
+        while (p->next)
+        {
+            len++;
+            p = p->next;
+        }
+        k %= len;
+        if (k == 0)
+            return head;
+
+        p->next = head;
+
+        int index = 1;
+        while (index < (len - k))
+        {
+            index++;
+            q = q->next;
+        }
+        ListNode *ret = q->next;
+        q->next = NULL;
+        return ret;
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    ListNode *rotateRight(ListNode *head, int k)
+    {
+        if (!head || !k || !head->next)
+            return head;
+        ListNode *temp = head;
+        int n;
+        for (n = 1; temp->next != NULL; n++)
+        {
+            temp = temp->next;
+        }
+        temp->next = head;
+        ListNode *Node = head;
+        for (int i = 0; i < n - k % n - 1; i++)
+        {
+            Node = Node->next;
+        }
+        ListNode *new_head = Node->next;
+        Node->next = NULL;
+        return new_head;
+    }
+};
+```

data/3.算法高阶/1.leetcode/61_不同路径/solution.md

+# 不同路径
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    int m = 3;
+    int n = 7;
+    int res;
+
+    res = sol.uniquePaths(m, n);
+    cout << res;
+    return 0;
+}
+```
+
+## 答案
+```cpp
+
+class Solution
+{
+public:
+    int uniquePaths(int m, int n)
+    {
+        vector<vector<int>> path(m, vector<int>(n, 0));
+        for (int i = 0; i < n; i++)
+            path[0][i] = 1;
+        for (int i = 0; i < m; i++)
+            path[i][0] = 1;
+        for (int i = 1; i < n; i++)
+            for (int j = 1; j < m; j++)
+                path[j][i] = path[j - 1][i + 1] + path[j + 1][i - 1];
+        return path[m - 1][n - 1];
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+typedef vector<int> BigInt;
+class Solution
+{
+public:
+    int uniquePaths(int m, int n)
+    {
+        if (m == 0 || n == 0)
+            return 0;
+        if (m == 1 || n == 1)
+            return 1;
+        int m_ = m - 1 + n - 1;
+        int n_ = n - 1;
+        BigInt a = fac(m_);
+        int result = 0;
+        for (int i = n_; i >= 1; i--)
+            a = div(a, i);
+        for (int i = m_ - n_; i >= 1; i--)
+            a = div(a, i);
+        int k = a.size() - 1;
+        while (a[k] == 0)
+            k--;
+        for (int i = k; i >= 0; i--)
+            result = result * 10 + a[i];
+
+        return result;
+    }
+
+    BigInt fac(int n)
+    {
+        BigInt result;
+        result.push_back(1);
+        for (int factor = 1; factor <= n; ++factor)
+        {
+            long long carry = 0;
+            for (auto &item : result)
+            {
+                long long product = item * factor + carry;
+                item = product % 10;
+                carry = product / 10;
+            }
+            if (carry > 0)
+            {
+                while (carry > 0)
+                {
+                    result.push_back(carry % 10);
+                    carry /= 10;
+                }
+            }
+        }
+        return result;
+    }
+    BigInt div(BigInt a, int d)
+    {
+        int b = 0;
+        BigInt result;
+        int len = a.size();
+        for (int i = len - 1; i >= 0; i--)
+        {
+            b = b * 10 + a[i];
+            result.insert(result.begin(), b / d);
+            b = b % d;
+        }
+        return result;
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    int uniquePaths(int m, int n)
+    {
+        if (m <= 0 || n <= 0)
+        {
+            return 0;
+        }
+
+        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
+        for (int i = 0; i < m; i++)
+        {
+            dp[i][0] = 1;
+        }
+        for (int i = 0; i < n; i++)
+        {
+            dp[0][i] = 1;
+        }
+
+        for (int i = 1; i < m; i++)
+        {
+            for (int j = 1; j < n; j++)
+            {
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    int uniquePaths(int m, int n)
+    {
+        int N = m + n - 2;
+        int M = m < n ? m - 1 : n - 1;
+
+        long ans = 1;
+        for (int i = 1; i <= M; i++)
+            ans = ans * (N - i + 1) / i;
+        return ans;
+    }
+};
+```

data/3.算法高阶/1.leetcode/62_不同路径 II/solution.md

+# 不同路径 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+```
+### after
+```cpp
+int main()
+{
+    Solution sol;
+    int a = 2;
+    int b = 4;
+    vector<vector<int>> obstacleGrid = vector<vector<int>>(a, vector<int>(b)) = {{0, 0, 0, 0}, {0, 1, 2, 3}};
+    int res;
+
+    res = sol.uniquePathsWithObstacles(obstacleGrid);
+    cout << res;
+    return 0;
+}
+```
+
+## 答案
+```cpp
+class Solution
+{
+public:
+    int dp[110];
+    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid)
+    {
+        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
+        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1)
+            return 0;
+        dp[1] = 1;
+        for (int i = 1; i <= m; ++i)
+        {
+            for (int j = 1; j <= n; ++j)
+            {
+                if (obstacleGrid[i - 1][j - 1] == 0)
+                    dp[j] += dp[j - 1];
+                else
+                    dp[j] = 0;
+            }
+        }
+        return dp[n];
+    }
+};
+```
+## 选项
+
+### A
+```cpp
+class Solution
+{
+public:
+    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid)
+    {
+        int m = obstacleGrid.size(), n = obstacleGrid[0].size();
+        vector<vector<int>> dp(m, vector<int>(n, 0));
+        for (int i = 0; i < m && obstacleGrid[i][0] != 1; i++)
+        {
+            dp[i][0] = 1;
+        }
+        for (int i = 0; i < n && obstacleGrid[0][i] != 1; i++)
+        {
+            dp[0][i] = 1;
+        }
+        for (int i = 1; i < m; i++)
+        {
+            for (int j = 1; j < n; j++)
+            {
+                if (obstacleGrid[i][j] != 1)
+                {
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+};
+```
+
+### B
+```cpp
+class Solution
+{
+public:
+    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid)
+    {
+        int m = obstacleGrid.size();
+        int n = obstacleGrid[0].size();
+        int p[m][n];
+
+        int k = 0;
+        while (k < m && obstacleGrid[k][0] != 1)
+            p[k++][0] = 1;
+
+        while (k < m)
+            p[k++][0] = 0;
+
+        k = 0;
+        while (k < n && obstacleGrid[0][k] != 1)
+            p[0][k++] = 1;
+        while (k < n)
+            p[0][k++] = 0;
+
+        for (int i = 1; i < m; i++)
+            for (int j = 1; j < n; j++)
+            {
+                if (obstacleGrid[i][j] == 1)
+                    p[i][j] = 0;
+                else
+                    p[i][j] = p[i - 1][j] + p[i][j - 1];
+            }
+        return p[m - 1][n - 1];
+    }
+};
+```
+
+### C
+```cpp
+class Solution
+{
+public:
+    int uniquePathsWithObstacles(vector<vector<int>> &obstacleGrid)
+    {
+        if (obstacleGrid.size() == 0 || obstacleGrid[0].size() == 0)
+            return 0;
+        int m = obstacleGrid.size();
+        int n = obstacleGrid[0].size();
+        vector<vector<int>> info(m, vector<int>(n, 0));
+        for (int i = 0; i < m; ++i)
+        {
+            if (obstacleGrid[i][0] == 1)
+            {
+                for (int j = i; j < m; j++)
+                {
+                    info[j][0] = 0;
+                }
+                break;
+            }
+            else
+                info[i][0] = 1;
+        }
+        for (int i = 0; i < n; ++i)
+        {
+            if (obstacleGrid[0][i] == 1)
+            {
+                for (int j = i; j < n; ++j)
+                {
+                    info[0][j] = 0;
+                }
+                break;
+            }
+            else
+                info[0][i] = 1;
+        }
+        for (int i = 1; i < m; ++i)
+        {
+            for (int j = 1; j < n; ++j)
+            {
+                if (obstacleGrid[i][j] == 1)
+                {
+                    info[i][j] = 0;
+                }
+                else
+                {
+                    info[i][j] = info[i - 1][j] + info[i][j - 1];
+                }
+            }
+        }
+        return info[m - 1][n - 1];
+    }
+};
+```

data/3.算法高阶/1.leetcode/63_最小路径和/solution.md

+# 最小路径和
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/64_有效数字/solution.md

+# 有效数字
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/65_加一/solution.md

+# 加一
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/66_二进制求和/solution.md

+# 二进制求和
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/67_文本左右对齐/solution.md

+# 文本左右对齐
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/68_x 的平方根/solution.md

+# x 的平方根
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/69_爬楼梯/solution.md

+# 爬楼梯
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/70_简化路径/solution.md

+# 简化路径
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/71_编辑距离/solution.md

+# 编辑距离
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/72_矩阵置零/solution.md

+# 矩阵置零
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/73_搜索二维矩阵/solution.md

+# 搜索二维矩阵
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/74_颜色分类/solution.md

+# 颜色分类
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/75_最小覆盖子串/solution.md

+# 最小覆盖子串
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/76_组合/solution.md

+# 组合
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/77_子集/solution.md

+# 子集
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/78_单词搜索/solution.md

+# 单词搜索
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/79_删除有序数组中的重复项 II/solution.md

+# 删除有序数组中的重复项 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/80_搜索旋转排序数组 II/solution.md

+# 搜索旋转排序数组 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/81_删除排序链表中的重复元素 II/solution.md

+# 删除排序链表中的重复元素 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/82_删除排序链表中的重复元素/solution.md

+# 删除排序链表中的重复元素
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/83_柱状图中最大的矩形/solution.md

+# 柱状图中最大的矩形
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/84_最大矩形/solution.md

+# 最大矩形
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/85_分隔链表/solution.md

+# 分隔链表
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/86_扰乱字符串/solution.md

+# 扰乱字符串
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/87_合并两个有序数组/solution.md

+# 合并两个有序数组
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/88_格雷编码/solution.md

+# 格雷编码
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/89_子集 II/solution.md

+# 子集 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/90_解码方法/solution.md

+# 解码方法
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/91_反转链表 II/solution.md

+# 反转链表 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/92_复原 IP 地址/solution.md

+# 复原 IP 地址
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/93_二叉树的中序遍历/solution.md

+# 二叉树的中序遍历
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/94_不同的二叉搜索树 II/solution.md

+# 不同的二叉搜索树 II
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/95_不同的二叉搜索树/solution.md

+# 不同的二叉搜索树
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/96_交错字符串/solution.md

+# 交错字符串
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/97_验证二叉搜索树/solution.md

+# 验证二叉搜索树
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/98_恢复二叉搜索树/solution.md

+# 恢复二叉搜索树
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```

data/3.算法高阶/1.leetcode/99_相同的树/solution.md

+# 相同的树
+以下错误的选项是？
+## aop
+### before
+```cpp
+
+```
+### after
+```cpp
+
+```
+
+## 答案
+```cpp
+
+```
+## 选项
+
+### A
+```cpp
+
+```
+
+### B
+```cpp
+
+```
+
+### C
+```cpp
+
+```