add exercises

data/3.算法高阶/1.leetcode/100_对称二叉树/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/3.算法高阶/1.leetcode/101_二叉树的层序遍历/solution.cpp

+#include <vector>
+#include <deque>
+#include <cstddef>
+
+using std::deque;
+using std::vector;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    vector<vector<int>> levelOrder(TreeNode *root)
+    {
+        vector<vector<int>> retv;
+        if (root)
+        {
+            deque<TreeNode *> q{root};
+            while (!q.empty())
+            {
+                vector<int> v;
+                for (decltype(q.size()) i = 0, n = q.size(); i != n; ++i)
+                {
+                    TreeNode *node = q.front();
+                    q.pop_front();
+                    v.push_back(node->val);
+                    if (node->left)
+                        q.push_back(node->left);
+                    if (node->right)
+                        q.push_back(node->right);
+                }
+                retv.push_back(v);
+            }
+        }
+        return retv;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/102_二叉树的锯齿形层序遍历/solution.cpp

+#include <vector>
+#include <queue>
+#include <cstddef>
+
+using std::vector;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    vector<vector<int>> zigzagLevelOrder(TreeNode *root)
+    {
+        vector<vector<int>> retv;
+        if (!root)
+            return retv;
+        std::queue<TreeNode *> q;
+        q.push(root);
+        bool reverse = false;
+        vector<int> v;
+        for (int cur_level_sz = 1, next_level_sz = 0; !q.empty();)
+        {
+            TreeNode *node = q.front();
+            q.pop();
+            v.push_back(node->val);
+            --cur_level_sz;
+            if (node->left)
+            {
+                q.push(node->left);
+                ++next_level_sz;
+            }
+            if (node->right)
+            {
+                q.push(node->right);
+                ++next_level_sz;
+            }
+            if (!cur_level_sz)
+            {
+                retv.push_back(reverse ? vector<int>(v.crbegin(), v.crend()) : v);
+                v.clear();
+                cur_level_sz = next_level_sz;
+                next_level_sz = 0;
+                reverse = !reverse;
+            }
+        }
+        return retv;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/103_二叉树的最大深度/solution.cpp

+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    int maxDepth(TreeNode *root)
+    {
+        if (root == NULL)
+            return 0;
+        return std::max(maxDepth(root->left), maxDepth(root->right)) + 1;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/104_从前序与中序遍历序列构造二叉树/solution.cpp

+#include <vector>
+#include <cstddef>
+#include <algorithm>
+
+using std::next;
+using std::prev;
+using std::vector;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    using cIter = vector<int>::const_iterator;
+    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder)
+    {
+        return buildTree(preorder.cbegin(), preorder.cend(), inorder.cbegin(), inorder.cend());
+    }
+    TreeNode *buildTree(cIter preBeg, cIter preEnd, cIter inBeg, cIter inEnd)
+    {
+        if (preBeg >= preEnd || inBeg >= inEnd)
+            return NULL;
+        TreeNode *root = new TreeNode(*preBeg);
+        auto inRoot = std::find(inBeg, inEnd, root->val);
+        root->left = buildTree(next(preBeg), next(preBeg, inRoot - inBeg + 1), inBeg, inRoot);
+        root->right = buildTree(next(preBeg, inRoot - inBeg + 1), preEnd, next(inRoot), inEnd);
+        return root;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/105_从中序与后序遍历序列构造二叉树/solution.cpp

+#include <cstddef>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    using vcIt = vector<int>::const_iterator;
+    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder)
+    {
+        return buildTree(inorder.cbegin(), inorder.cend(), postorder.cbegin(), postorder.cend());
+    }
+    TreeNode *buildTree(vcIt inBeg, vcIt inEnd, vcIt postBeg, vcIt postEnd)
+    {
+        if (inBeg >= inEnd || postBeg >= postEnd)
+            return NULL;
+        TreeNode *root = new TreeNode(*prev(postEnd));
+        auto inRoot = find(inBeg, inEnd, root->val);
+        root->left = buildTree(inBeg, inRoot, postBeg, next(postBeg, inRoot - inBeg));
+        root->right = buildTree(next(inRoot), inEnd, next(postBeg, inRoot - inBeg), prev(postEnd));
+        return root;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/106_二叉树的层序遍历 II/solution.cpp

+
+
+#include <vector>
+using std::vector;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    vector<vector<int>> levelOrderBottom(TreeNode *root)
+    {
+        levelOrderBottom(root, 0);
+        return vector<vector<int>>(vec_.rbegin(), vec_.rend());
+    }
+
+private:
+    void levelOrderBottom(TreeNode *root, int level)
+    {
+        if (root == NULL)
+            return;
+        if (vec_.size() == level)
+            vec_.push_back({root->val});
+        else
+            vec_[level].push_back(root->val);
+        levelOrderBottom(root->left, level + 1);
+        levelOrderBottom(root->right, level + 1);
+    }
+
+private:
+    vector<vector<int>> vec_;
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/107_将有序数组转换为二叉搜索树/solution.cpp

+#include <vector>
+#include <cstddef>
+using std::vector;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    TreeNode *sortedArrayToBST(vector<int> &num)
+    {
+        return sortedArrayToBST(num.begin(), num.end());
+    }
+
+    TreeNode *sortedArrayToBST(vector<int>::iterator beg, vector<int>::iterator end)
+    {
+        if (beg == end)
+            return NULL;
+        auto mid = beg + (end - beg) / 2;
+        TreeNode *root = new TreeNode(*mid);
+        root->left = sortedArrayToBST(beg, mid);
+        root->right = sortedArrayToBST(std::next(mid), end);
+        return root;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/108_有序链表转换二叉搜索树/solution.cpp

+#include <cstddef>
+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    TreeNode *sortedListToBST(ListNode *head)
+    {
+        auto n = [](ListNode *p)
+        {
+            int count{0};
+            for (; p; p = p->next, ++count)
+                ;
+            return count;
+        }(head);
+        return sortedListToBST(&head, n);
+    }
+    TreeNode *sortedListToBST(ListNode **head_ref, int n)
+    {
+        if (n < 1)
+            return NULL;
+        TreeNode *left = sortedListToBST(head_ref, n / 2);
+        TreeNode *root = new TreeNode((*head_ref)->val);
+        root->left = left;
+        *head_ref = (*head_ref)->next;
+        root->right = sortedListToBST(head_ref, n - n / 2 - 1);
+        return root;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/109_平衡二叉树/solution.cpp

+#include <complex>
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    bool isBalanced(TreeNode *root)
+    {
+        height(root);
+        return bBalanced;
+    }
+
+private:
+    int height(TreeNode *node)
+    {
+        if (node == NULL || !bBalanced)
+            return 0;
+        else
+        {
+            int leftHeight = height(node->left);
+            int rightHeight = height(node->right);
+            if (std::abs(leftHeight - rightHeight) > 1)
+                bBalanced = false;
+            return std::max(leftHeight, rightHeight) + 1;
+        }
+    }
+
+    bool bBalanced = true;
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/110_二叉树的最小深度/solution.cpp

+#include <algorithm>
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    int minDepth(TreeNode *root)
+    {
+        if (!root)
+            return 0;
+        else if (!root->left and !root->right)
+            return 1;
+        else if (root->left and root->right)
+            return 1 + std::min(minDepth(root->left), minDepth(root->right));
+        else
+            return 1 + (root->left ? minDepth(root->left) : minDepth(root->right));
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/111_路径总和/solution.cpp

+#include <cstddef>
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    bool hasPathSum(TreeNode *root, int sum)
+    {
+        if (!root)
+            return false;
+        if (!root->left and !root->right and sum - root->val == 0)
+            return true;
+        return hasPathSum(root->left, sum - root->val) or hasPathSum(root->right, sum - root->val);
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/112_路径总和 II/solution.cpp

+#include <vector>
+#include <cstddef>
+#include <stack>
+#include <algorithm>
+using std::vector;
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    vector<vector<int>> pathSum(TreeNode *root, int sum)
+    {
+        vector<vector<int>> ret;
+        vector<int> path;
+        pathSum(root, sum, path, ret);
+        return ret;
+    }
+    void pathSum(TreeNode *root, int sum, vector<int> &path, vector<vector<int>> &ret)
+    {
+        if (!root)
+            return;
+        path.push_back(root->val);
+        if (!root->left && !root->right && root->val == sum)
+            ret.push_back(path);
+        if (root->left)
+            pathSum(root->left, sum - root->val, path, ret);
+        if (root->right)
+            pathSum(root->right, sum - root->val, path, ret);
+        path.pop_back();
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/113_二叉树展开为链表/solution.cpp

+
+
+#include <cstddef>
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    void flatten(TreeNode *root)
+    {
+        for (; root; root = root->right)
+            if (root->left)
+            {
+                TreeNode *end = root->left;
+                while (end->right)
+                    end = end->right;
+                end->right = root->right;
+                root->right = root->left;
+                root->left = NULL;
+            }
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/114_不同的子序列/solution.cpp

+#include <string>
+using std::string;
+#include <vector>
+using std::vector;
+
+class Solution
+{
+public:
+    int numDistinct(string S, string T)
+    {
+        int m = static_cast<int>(S.size());
+        int n = static_cast<int>(T.size());
+        if (m < n)
+            return 0;
+        vector<int> v(n + 1, 0);
+        v[0] = 1;
+        for (int i = 1; i <= m; ++i)
+            for (int j = std::min(i, n) + 1; j > 0; --j)
+                if (S[i - 1] == T[j - 1])
+                    v[j] += v[j - 1];
+
+        return v.back();
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/115_填充每个节点的下一个右侧节点指针/desc.html

+<p>给定一个 <strong>完美二叉树 </strong>，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：</p>
+
+<pre>
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}</pre>
+
+<p>填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 <code>NULL</code>。</p>
+
+<p>初始状态下，所有 next 指针都被设置为 <code>NULL</code>。</p>
+
+<p> </p>
+
+<p><strong>进阶：</strong></p>
+
+<ul>
+	<li>你只能使用常量级额外空间。</li>
+	<li>使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。</li>
+</ul>
+
+<p> </p>
+
+<p><strong>示例：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2019/02/14/116_sample.png" style="height: 205px; width: 600px;" /></p>
+
+<pre>
+<b>输入：</b>root = [1,2,3,4,5,6,7]
+<b>输出：</b>[1,#,2,3,#,4,5,6,7,#]
+<b>解释：</b>给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中节点的数量少于 <code>4096</code></li>
+	<li><code>-1000 <= node.val <= 1000</code></li>
+</ul>

data/3.算法高阶/1.leetcode/115_填充每个节点的下一个右侧节点指针/solution.cpp

+#include <stack>
+
+struct TreeLinkNode
+{
+    int val;
+    TreeLinkNode *left, *right, *next;
+    TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    void connect(TreeLinkNode *root)
+    {
+        if (root == NULL)
+            return;
+        while (root->left)
+        {
+            root->left->next = root->right;
+            for (TreeLinkNode *cur = root; cur->next; cur = cur->next)
+            {
+                cur->right->next = cur->next->left;
+                cur->next->left->next = cur->next->right;
+            }
+            root = root->left;
+        }
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/116_填充每个节点的下一个右侧节点指针 II/solution.cpp

+struct TreeLinkNode
+{
+    int val;
+    TreeLinkNode *left, *right, *next;
+    TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    void connect(TreeLinkNode *root)
+    {
+        while (root and (root->left or root->right))
+        {
+            if (root->left and root->right)
+                root->left->next = root->right;
+            for (TreeLinkNode *cur = root, *find = root->next; find; find = find->next)
+            {
+                if (!find->left and !find->right)
+                    continue;
+                if (find->left and find->right)
+                    find->left->next = find->right;
+                (cur->right ? cur->right->next : cur->left->next) = find->left ? find->left : find->right;
+                cur = find;
+            }
+            root = root->left ? root->left : root->right;
+            while (root->next && !root->left and !root->right)
+                root = root->next;
+        }
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/117_杨辉三角/solution.cpp

+#include <vector>
+
+using std::vector;
+
+class Solution
+{
+public:
+    vector<vector<int>> generate(int numRows)
+    {
+        vector<vector<int>> vec;
+        for (int i = 0; i < numRows; ++i)
+        {
+            vector<int> row;
+            if (!vec.empty())
+                row.assign(vec.at(i - 1).begin(), vec.at(i - 1).end());
+            row.push_back(1);
+            for (int j = i - 1; j > 0; --j)
+                row[j] += row[j - 1];
+            vec.push_back(row);
+        }
+        return vec;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1183_公交站间的距离/desc.html

+<p>环形公交路线上有&nbsp;<code>n</code>&nbsp;个站，按次序从&nbsp;<code>0</code>&nbsp;到&nbsp;<code>n - 1</code>&nbsp;进行编号。我们已知每一对相邻公交站之间的距离，<code>distance[i]</code>&nbsp;表示编号为&nbsp;<code>i</code>&nbsp;的车站和编号为&nbsp;<code>(i + 1) % n</code>&nbsp;的车站之间的距离。</p>
+
+<p>环线上的公交车都可以按顺时针和逆时针的方向行驶。</p>
+
+<p>返回乘客从出发点&nbsp;<code>start</code>&nbsp;到目的地&nbsp;<code>destination</code>&nbsp;之间的最短距离。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/08/untitled-diagram-1.jpg" style="height: 240px; width: 388px;"></p>
+
+<pre><strong>输入：</strong>distance = [1,2,3,4], start = 0, destination = 1
+<strong>输出：</strong>1
+<strong>解释：</strong>公交站 0 和 1 之间的距离是 1 或 9，最小值是 1。</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 2：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/08/untitled-diagram-1-1.jpg" style="height: 240px; width: 388px;"></p>
+
+<pre><strong>输入：</strong>distance = [1,2,3,4], start = 0, destination = 2
+<strong>输出：</strong>3
+<strong>解释：</strong>公交站 0 和 2 之间的距离是 3 或 7，最小值是 3。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 3：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/08/untitled-diagram-1-2.jpg" style="height: 240px; width: 388px;"></p>
+
+<pre><strong>输入：</strong>distance = [1,2,3,4], start = 0, destination = 3
+<strong>输出：</strong>4
+<strong>解释：</strong>公交站 0 和 3 之间的距离是 6 或 4，最小值是 4。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n&nbsp;&lt;= 10^4</code></li>
+	<li><code>distance.length == n</code></li>
+	<li><code>0 &lt;= start, destination &lt; n</code></li>
+	<li><code>0 &lt;= distance[i] &lt;= 10^4</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1184_一周中的第几天/desc.html

+<p>给你一个日期，请你设计一个算法来判断它是对应一周中的哪一天。</p>
+
+<p>输入为三个整数：<code>day</code>、<code>month</code> 和&nbsp;<code>year</code>，分别表示日、月、年。</p>
+
+<p>您返回的结果必须是这几个值中的一个&nbsp;<code>{&quot;Sunday&quot;, &quot;Monday&quot;, &quot;Tuesday&quot;, &quot;Wednesday&quot;, &quot;Thursday&quot;, &quot;Friday&quot;, &quot;Saturday&quot;}</code>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>day = 31, month = 8, year = 2019
+<strong>输出：</strong>&quot;Saturday&quot;
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>day = 18, month = 7, year = 1999
+<strong>输出：</strong>&quot;Sunday&quot;
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>day = 15, month = 8, year = 1993
+<strong>输出：</strong>&quot;Sunday&quot;
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>给出的日期一定是在&nbsp;<code>1971</code> 到&nbsp;<code>2100</code>&nbsp;年之间的有效日期。</li>
+</ul>

data/3.算法高阶/1.leetcode/1188_“气球” 的最大数量/desc.html

+<p>给你一个字符串&nbsp;<code>text</code>，你需要使用 <code>text</code> 中的字母来拼凑尽可能多的单词&nbsp;<strong>&quot;balloon&quot;（气球）</strong>。</p>
+
+<p>字符串&nbsp;<code>text</code> 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词&nbsp;<strong>&quot;balloon&quot;</strong>。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/14/1536_ex1_upd.jpeg" style="height: 35px; width: 154px;"></strong></p>
+
+<pre><strong>输入：</strong>text = &quot;nlaebolko&quot;
+<strong>输出：</strong>1
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/09/14/1536_ex2_upd.jpeg" style="height: 35px; width: 233px;"></strong></p>
+
+<pre><strong>输入：</strong>text = &quot;loonbalxballpoon&quot;
+<strong>输出：</strong>2
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>text = &quot;leetcode&quot;
+<strong>输出：</strong>0
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= text.length &lt;= 10^4</code></li>
+	<li><code>text</code>&nbsp;全部由小写英文字母组成</li>
+</ul>

data/3.算法高阶/1.leetcode/1189_反转每对括号间的子串/desc.html

+<p>给出一个字符串 <code>s</code>（仅含有小写英文字母和括号）。</p>
+
+<p>请你按照从括号内到外的顺序，逐层反转每对匹配括号中的字符串，并返回最终的结果。</p>
+
+<p>注意，您的结果中 <strong>不应</strong> 包含任何括号。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "(abcd)"
+<strong>输出：</strong>"dcba"
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "(u(love)i)"
+<strong>输出：</strong>"iloveu"
+<strong>解释：</strong>先反转子字符串 "love" ，然后反转整个字符串。</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "(ed(et(oc))el)"
+<strong>输出：</strong>"leetcode"
+<strong>解释：</strong>先反转子字符串 "oc" ，接着反转 "etco" ，然后反转整个字符串。</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "a(bcdefghijkl(mno)p)q"
+<strong>输出：</strong>"apmnolkjihgfedcbq"
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>0 <= s.length <= 2000</code></li>
+	<li><code>s</code> 中只有小写英文字母和括号</li>
+	<li>题目测试用例确保所有括号都是成对出现的</li>
+</ul>

data/3.算法高阶/1.leetcode/118_杨辉三角 II/desc.html

+<p>给定一个非负索引 <code>rowIndex</code>，返回「杨辉三角」的第 <code>rowIndex</code><em> </em>行。</p>
+
+<p><small>在「杨辉三角」中，每个数是它左上方和右上方的数的和。</small></p>
+
+<p><img alt="" src="https://pic.leetcode-cn.com/1626927345-DZmfxB-PascalTriangleAnimated2.gif" /></p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> rowIndex = 3
+<strong>输出:</strong> [1,3,3,1]
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> rowIndex = 0
+<strong>输出:</strong> [1]
+</pre>
+
+<p><strong>示例 3:</strong></p>
+
+<pre>
+<strong>输入:</strong> rowIndex = 1
+<strong>输出:</strong> [1,1]
+</pre>
+
+<p> </p>
+
+<p><strong>提示:</strong></p>
+
+<ul>
+	<li><code>0 <= rowIndex <= 33</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong></p>
+
+<p>你可以优化你的算法到 <code><em>O</em>(<i>rowIndex</i>)</code> 空间复杂度吗？</p>

data/3.算法高阶/1.leetcode/118_杨辉三角 II/solution.cpp

+#include <vector>
+using std::vector;
+
+class Solution
+{
+public:
+    vector<int> getRow(int rowIndex)
+    {
+        vector<int> vec(rowIndex + 1, 0);
+        vec[0] = 1;
+        for (int i = 0; i <= rowIndex; ++i)
+            for (int j = i; j > 0; --j)
+                vec[j] += vec[j - 1];
+        return vec;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1191_查找集群内的「关键连接」/desc.html

+<p>力扣数据中心有&nbsp;<code>n</code>&nbsp;台服务器，分别按从&nbsp;<code>0</code>&nbsp;到&nbsp;<code>n-1</code>&nbsp;的方式进行了编号。</p>
+
+<p>它们之间以「服务器到服务器」点对点的形式相互连接组成了一个内部集群，其中连接&nbsp;<code>connections</code> 是无向的。</p>
+
+<p>从形式上讲，<code>connections[i] = [a, b]</code>&nbsp;表示服务器 <code>a</code>&nbsp;和 <code>b</code>&nbsp;之间形成连接。任何服务器都可以直接或者间接地通过网络到达任何其他服务器。</p>
+
+<p>「关键连接」是在该集群中的重要连接，也就是说，假如我们将它移除，便会导致某些服务器无法访问其他服务器。</p>
+
+<p>请你以任意顺序返回该集群内的所有 「关键连接」。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/original_images/critical-connections-in-a-network.png" style="width: 150px;"></strong></p>
+
+<pre><strong>输入：</strong>n = 4, connections = [[0,1],[1,2],[2,0],[1,3]]
+<strong>输出：</strong>[[1,3]]
+<strong>解释：</strong>[[3,1]] 也是正确的。</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10^5</code></li>
+	<li><code>n-1 &lt;= connections.length &lt;= 10^5</code></li>
+	<li><code>connections[i][0] != connections[i][1]</code></li>
+	<li>不存在重复的连接</li>
+</ul>

data/3.算法高阶/1.leetcode/119_三角形最小路径和/desc.html

+<p>给定一个三角形 <code>triangle</code> ，找出自顶向下的最小路径和。</p>
+
+<p>每一步只能移动到下一行中相邻的结点上。<strong>相邻的结点 </strong>在这里指的是 <strong>下标</strong> 与 <strong>上一层结点下标</strong> 相同或者等于 <strong>上一层结点下标 + 1</strong> 的两个结点。也就是说，如果正位于当前行的下标 <code>i</code> ，那么下一步可以移动到下一行的下标 <code>i</code> 或 <code>i + 1</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+<strong>输出：</strong>11
+<strong>解释：</strong>如下面简图所示：
+   <strong>2</strong>
+  <strong>3</strong> 4
+ 6 <strong>5</strong> 7
+4 <strong>1</strong> 8 3
+自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>triangle = [[-10]]
+<strong>输出：</strong>-10
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= triangle.length <= 200</code></li>
+	<li><code>triangle[0].length == 1</code></li>
+	<li><code>triangle[i].length == triangle[i - 1].length + 1</code></li>
+	<li><code>-10<sup>4</sup> <= triangle[i][j] <= 10<sup>4</sup></code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong></p>
+
+<ul>
+	<li>你可以只使用 <code>O(n)</code> 的额外空间（<code>n</code> 为三角形的总行数）来解决这个问题吗？</li>
+</ul>

data/3.算法高阶/1.leetcode/119_三角形最小路径和/solution.cpp

+#include <vector>
+#include <algorithm>
+#include <iostream>
+
+using namespace std;
+
+class Solution
+{
+public:
+    int minimumTotal(vector<vector<int>> &triangle)
+    {
+        vector<int> steps;
+        for (auto &v : triangle)
+        {
+            if (!steps.empty())
+            {
+                v.front() += steps.front();
+                v.back() += steps.back();
+            }
+            for (size_t i = 1; i < steps.size(); ++i)
+                v[i] += min(steps.at(i - 1), steps.at(i));
+            steps = v;
+        }
+        return *min_element(steps.cbegin(), steps.cend());
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/120_买卖股票的最佳时机/solution.cpp

+#include <vector>
+#include <algorithm>
+using std::max;
+using std::min;
+using std::vector;
+
+class Solution
+{
+public:
+    int maxProfit(vector<int> &prices)
+    {
+        if (prices.empty())
+            return 0;
+        int ret{0}, low{prices[0]};
+        for (auto price : prices)
+        {
+            low = min(low, price);
+            ret = max(ret, price - low);
+        }
+        return ret;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/121_买卖股票的最佳时机 II/solution.cpp

+
+
+#include <vector>
+using std::vector;
+
+class Solution
+{
+public:
+    int maxProfit(vector<int> &prices)
+    {
+        int profit = 0;
+        for (auto i = prices.begin(); i != prices.end(); ++i)
+            if (i + 1 != prices.end() && *(i + 1) > *i)
+                profit += *(i + 1) - *i;
+        return profit;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/122_买卖股票的最佳时机 III/solution.cpp

+#include <vector>
+using std::vector;
+#include <algorithm>
+using std::max;
+using std::min;
+
+class Solution
+{
+public:
+    int maxProfit(vector<int> &prices)
+    {
+        if (prices.empty())
+            return 0;
+        int low = prices.front(), high = prices.back(), ret = 0;
+        vector<int> history;
+        history.reserve(prices.size());
+        for (auto today : prices)
+        {
+            low = min(low, today);
+            ret = max(ret, today - low);
+            history.push_back(ret);
+        }
+        for (auto today = prices.crbegin(), past = history.crbegin(); today != prices.crend(); ++today, ++past)
+        {
+            high = max(high, *today);
+            ret = max(ret, *past + high - *today);
+        }
+        return ret;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/123_二叉树中的最大路径和/desc.html

+<p><strong>路径</strong> 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 <strong>至多出现一次</strong> 。该路径<strong> 至少包含一个 </strong>节点，且不一定经过根节点。</p>
+
+<p><strong>路径和</strong> 是路径中各节点值的总和。</p>
+
+<p>给你一个二叉树的根节点 <code>root</code> ，返回其 <strong>最大路径和</strong> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx1.jpg" style="width: 322px; height: 182px;" />
+<pre>
+<strong>输入：</strong>root = [1,2,3]
+<strong>输出：</strong>6
+<strong>解释：</strong>最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2020/10/13/exx2.jpg" />
+<pre>
+<strong>输入：</strong>root = [-10,9,20,null,null,15,7]
+<strong>输出：</strong>42
+<strong>解释：</strong>最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>树中节点数目范围是 <code>[1, 3 * 10<sup>4</sup>]</code></li>
+	<li><code>-1000 <= Node.val <= 1000</code></li>
+</ul>

data/3.算法高阶/1.leetcode/123_二叉树中的最大路径和/solution.cpp

+#include <cstddef>
+#include <algorithm>
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+    int maxPathSum(TreeNode *root, int &maxSum)
+    {
+        if (!root)
+            return 0;
+        int leftMax = std::max(0, maxPathSum(root->left, maxSum));
+        int rightMax = std::max(0, maxPathSum(root->right, maxSum));
+        maxSum = std::max(maxSum, leftMax + rightMax + root->val);
+        return root->val + std::max(leftMax, rightMax);
+    }
+
+public:
+    int maxPathSum(TreeNode *root)
+    {
+        int maxSum = INT_MIN;
+        maxPathSum(root, maxSum);
+        return maxSum;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/124_验证回文串/desc.html

+<p>给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。</p>
+
+<p><strong>说明：</strong>本题中，我们将空字符串定义为有效的回文串。</p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入:</strong> "A man, a plan, a canal: Panama"
+<strong>输出:</strong> true
+<strong>解释：</strong>"amanaplanacanalpanama" 是回文串
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<pre>
+<strong>输入:</strong> "race a car"
+<strong>输出:</strong> false
+<strong>解释：</strong>"raceacar" 不是回文串
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= s.length <= 2 * 10<sup>5</sup></code></li>
+	<li>字符串 <code>s</code> 由 ASCII 字符组成</li>
+</ul>

data/3.算法高阶/1.leetcode/124_验证回文串/solution.cpp

+
+
+#include <string>
+using std::string;
+#include <cctype>
+
+class Solution
+{
+public:
+    bool isPalindrome(string s)
+    {
+        for (auto b = s.cbegin(), e = std::prev(s.cend()); b < e; ++b, --e)
+        {
+            while (!isalnum(*b))
+                ++b;
+            while (!isalnum(*e))
+                --e;
+            if (b < e && tolower(*b) != tolower(*e))
+                return false;
+        }
+        return true;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/125_单词接龙 II/solution.cpp

+
+class Solution
+{
+public:
+    unordered_map<string, vector<string>> tree; // 构建图
+    vector<vector<string>> ans;                 // 存放最终结果
+
+    void dfs(vector<string> &cur, string curWord, string endWord)
+    {
+        if (curWord == endWord)
+        {
+            ans.push_back(cur);
+            return;
+        }
+        for (string s : tree[curWord])
+        {
+            cur.push_back(s);
+            dfs(cur, s, endWord);
+            cur.pop_back();
+        }
+    }
+
+    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string> &wordList)
+    {
+        if (wordList.size() == 0 || find(wordList.begin(), wordList.end(), endWord) == wordList.end())
+            return {};
+        unordered_set<string> bfsFromBegin{beginWord};                // 自顶向下的BFS队列 !!!注意使用集合
+        unordered_set<string> bfsFromEnd{endWord};                    // 自底向上的BFS队列 !!!注意使用集合
+        unordered_set<string> dirc(wordList.begin(), wordList.end()); // 初始化字典 记录未被访问过的字符串 !!!注意初始化方式
+        bool findFlag = false, reverseFlag = false;                   // findFlag两队列是否存在相同的元素 reverseflag时刻标记当前BFS遍历的方向（false为自顶向下，true为自底向上）
+        while (!bfsFromBegin.empty())
+        {
+            unordered_set<string> next;   // 存放下一层需要遍历的节点（由于此处BFS的特殊性【一次性扩展所有节点】，所以不是直接添加到原先队列的末尾，而是借助next）
+            for (string s : bfsFromBegin) // 遍历过的节点从set中删除 避免成环
+                dirc.erase(s);
+            for (string s1 : bfsFromBegin)
+            { // 扩展下一层的节点
+                for (int i = 0; i < s1.size(); ++i)
+                {
+                    string s2 = s1; // s2记录由s1扩展而来字符串 !!!注意这条语句不要放错位置
+                    for (char c = 'a'; c <= 'z'; ++c)
+                    {
+                        s2[i] = c;
+                        if (dirc.count(s2) == 0)
+                            continue;
+                        if (bfsFromEnd.count(s2))
+                        {
+                            findFlag = true; // 找到双向BFS重合的字符串，BFS过程即可终止
+                        }
+                        else
+                        {
+                            next.insert(s2); // 将字符串加入扩展队列
+                        }
+                        reverseFlag ? tree[s2].push_back(s1) : tree[s1].push_back(s2); // 构建树 并始终保持方向从beginWord指向endWord
+                    }
+                }
+            }
+            bfsFromBegin = next; // 更新队列
+            if (bfsFromBegin.size() > bfsFromEnd.size())
+            {
+                reverseFlag = !reverseFlag;     // 取反
+                swap(bfsFromBegin, bfsFromEnd); // 交换BFS的队列 改变BFS的方向
+            }
+            if (findFlag)
+                break; // 双向BFS交汇 BFS过程终止
+        }
+        vector<string> cur = {beginWord};
+        dfs(cur, beginWord, endWord); // 遍历形成的树 得到起点到终点的路径
+        return ans;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/126_单词接龙/solution.cpp

+//Dijkstra算法的思路
+class Solution
+{
+public:
+    int ladderLength(string beginWord, string endWord, vector<string> &wordList)
+    {
+        unordered_set<string> set(wordList.begin(), wordList.end());
+        if (!set.count(endWord))
+            return 0;
+        queue<pair<string, int>> q; //<字符串，该字符串到beginword的距离>
+        q.push({beginWord, 1});
+        while (!q.empty())
+        {
+            string cur = q.front().first;
+            int step = q.front().second;
+            q.pop();
+            if (cur == endWord)
+                return step;
+
+            for (int i = 0; i < cur.size(); ++i)
+            {
+                char ch = cur[i];
+                //遍历字母来寻找距离为1（只用改变一个字母）的单词，也即可达的单词
+                for (char c = 'a'; c <= 'z'; ++c)
+                {
+                    if (c == ch)
+                        continue;
+                    cur[i] = c; //替换单个字符
+                    if (set.count(cur))
+                    {
+                        q.push({cur, 1 + step});
+                        set.erase(cur); //该节点使用过了，需要进行删除
+                    }
+                }
+                cur[i] = ch; //复原
+            }
+        }
+        return 0;
+    }
+};

data/3.算法高阶/1.leetcode/1276_统计全为 1 的正方形子矩阵/desc.html

+<p>给你一个&nbsp;<code>m * n</code>&nbsp;的矩阵，矩阵中的元素不是 <code>0</code> 就是 <code>1</code>，请你统计并返回其中完全由 <code>1</code> 组成的 <strong>正方形</strong> 子矩阵的个数。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>matrix =
+[
+&nbsp; [0,1,1,1],
+&nbsp; [1,1,1,1],
+&nbsp; [0,1,1,1]
+]
+<strong>输出：</strong>15
+<strong>解释：</strong> 
+边长为 1 的正方形有 <strong>10</strong> 个。
+边长为 2 的正方形有 <strong>4</strong> 个。
+边长为 3 的正方形有 <strong>1</strong> 个。
+正方形的总数 = 10 + 4 + 1 = <strong>15</strong>.
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>matrix = 
+[
+  [1,0,1],
+  [1,1,0],
+  [1,1,0]
+]
+<strong>输出：</strong>7
+<strong>解释：</strong>
+边长为 1 的正方形有 <strong>6</strong> 个。 
+边长为 2 的正方形有 <strong>1</strong> 个。
+正方形的总数 = 6 + 1 = <strong>7</strong>.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= arr.length&nbsp;&lt;= 300</code></li>
+	<li><code>1 &lt;= arr[0].length&nbsp;&lt;= 300</code></li>
+	<li><code>0 &lt;= arr[i][j] &lt;= 1</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1277_分割回文串 III/desc.html

+<p>给你一个由小写字母组成的字符串&nbsp;<code>s</code>，和一个整数&nbsp;<code>k</code>。</p>
+
+<p>请你按下面的要求分割字符串：</p>
+
+<ul>
+	<li>首先，你可以将&nbsp;<code>s</code>&nbsp;中的部分字符修改为其他的小写英文字母。</li>
+	<li>接着，你需要把&nbsp;<code>s</code>&nbsp;分割成&nbsp;<code>k</code>&nbsp;个非空且不相交的子串，并且每个子串都是回文串。</li>
+</ul>
+
+<p>请返回以这种方式分割字符串所需修改的最少字符数。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;abc&quot;, k = 2
+<strong>输出：</strong>1
+<strong>解释：</strong>你可以把字符串分割成 &quot;ab&quot; 和 &quot;c&quot;，并修改 &quot;ab&quot; 中的 1 个字符，将它变成回文串。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;aabbc&quot;, k = 3
+<strong>输出：</strong>0
+<strong>解释：</strong>你可以把字符串分割成 &quot;aa&quot;、&quot;bb&quot; 和 &quot;c&quot;，它们都是回文串。</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;leetcode&quot;, k = 8
+<strong>输出：</strong>0
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= s.length &lt;= 100</code></li>
+	<li><code>s</code>&nbsp;中只含有小写英文字母。</li>
+</ul>

data/3.算法高阶/1.leetcode/127_最长连续序列/solution.cpp

+#include <vector>
+#include <unordered_map>
+using std::unordered_map;
+using std::vector;
+
+class Solution
+{
+public:
+    int longestConsecutive(vector<int> &num)
+    {
+        unordered_map<int, int> map;
+        int max{0};
+        for (auto i : num)
+            if (!map[i])
+            {
+                map[i] = map[i + 1] + map[i - 1] + 1;
+                map[i - map[i - 1]] = map[i + map[i + 1]] = map[i];
+                max = std::max(max, map[i]);
+            }
+        return max;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1280_整数的各位积和之差/desc.html

+<p>给你一个整数&nbsp;<code>n</code>，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 234
+<strong>输出：</strong>15 
+<strong>解释：</strong>
+各位数之积 = 2 * 3 * 4 = 24 
+各位数之和 = 2 + 3 + 4 = 9 
+结果 = 24 - 9 = 15
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 4421
+<strong>输出：</strong>21
+<strong>解释： 
+</strong>各位数之积 = 4 * 4 * 2 * 1 = 32 
+各位数之和 = 4 + 4 + 2 + 1 = 11 
+结果 = 32 - 11 = 21
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10^5</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1281_用户分组/desc.html

+<p>有&nbsp;<code>n</code>&nbsp;位用户参加活动，他们的&nbsp;<strong>ID</strong>&nbsp;从 <code>0</code> 到 <code>n - 1</code>，每位用户都 <strong>恰好</strong> 属于某一用户组。给你一个长度为 <code>n</code> 的数组&nbsp;<code>groupSizes</code>，其中包含每位用户所处的用户组的大小，请你返回用户分组情况（存在的用户组以及每个组中用户的 ID）。</p>
+
+<p>你可以任何顺序返回解决方案，ID 的顺序也不受限制。此外，题目给出的数据保证至少存在一种解决方案。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>groupSizes = [3,3,3,3,3,1,3]
+<strong>输出：</strong>[[5],[0,1,2],[3,4,6]]
+<strong>解释：</strong> 
+其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>groupSizes = [2,1,3,3,3,2]
+<strong>输出：</strong>[[1],[0,5],[2,3,4]]
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>groupSizes.length == n</code></li>
+	<li><code>1 &lt;= n&nbsp;&lt;= 500</code></li>
+	<li><code>1 &lt;=&nbsp;groupSizes[i] &lt;= n</code></li>
+</ul>

data/3.算法高阶/1.leetcode/128_求根节点到叶节点数字之和/solution.cpp

+
+
+#include <cstddef>
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    int sumNumbers(TreeNode *root)
+    {
+        return sumNumbers(root, 0);
+    }
+
+private:
+    int sumNumbers(TreeNode *root, int sum)
+    {
+        if (!root)
+            return 0;
+        else if (!root->left && !root->right)
+            return sum + root->val;
+        else
+            return sumNumbers(root->left, (root->val + sum) * 10) + sumNumbers(root->right, (root->val + sum) * 10);
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1292_网格中的最短路径/desc.html

+<p>给你一个&nbsp;<code>m * n</code>&nbsp;的网格，其中每个单元格不是&nbsp;<code>0</code>（空）就是&nbsp;<code>1</code>（障碍物）。每一步，您都可以在空白单元格中上、下、左、右移动。</p>
+
+<p>如果您 <strong>最多</strong> 可以消除 <code>k</code> 个障碍物，请找出从左上角 <code>(0, 0)</code> 到右下角 <code>(m-1, n-1)</code> 的最短路径，并返回通过该路径所需的步数。如果找不到这样的路径，则返回 -1。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong> 
+grid = 
+[[0,0,0],
+&nbsp;[1,1,0],
+ [0,0,0],
+&nbsp;[0,1,1],
+ [0,0,0]], 
+k = 1
+<strong>输出：</strong>6
+<strong>解释：
+</strong>不消除任何障碍的最短路径是 10。
+消除位置 (3,2) 处的障碍后，最短路径是 6 。该路径是 <code>(0,0) -&gt; (0,1) -&gt; (0,2) -&gt; (1,2) -&gt; (2,2) -&gt; <strong>(3,2)</strong> -&gt; (4,2)</code>.
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>
+grid = 
+[[0,1,1],
+&nbsp;[1,1,1],
+&nbsp;[1,0,0]], 
+k = 1
+<strong>输出：</strong>-1
+<strong>解释：
+</strong>我们至少需要消除两个障碍才能找到这样的路径。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>grid.length&nbsp;== m</code></li>
+	<li><code>grid[0].length&nbsp;== n</code></li>
+	<li><code>1 &lt;= m, n &lt;= 40</code></li>
+	<li><code>1 &lt;= k &lt;= m*n</code></li>
+	<li><code>grid[i][j] == 0 <strong>or</strong> 1</code></li>
+	<li><code>grid[0][0] == grid[m-1][n-1] == 0</code></li>
+</ul>

data/3.算法高阶/1.leetcode/129_被围绕的区域/solution.cpp

+class Solution
+{
+public:
+    int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0}, n, m;
+    void dfs(int row, int col, vector<vector<char>> &board)
+    {
+        board[row][col] = 'o';
+        for (int i = 0; i < 4; ++i)
+            if (row + dx[i] >= 0 && row + dx[i] < n && col + dy[i] >= 0 && col + dy[i] < m && board[row + dx[i]][col + dy[i]] == 'O')
+                dfs(row + dx[i], col + dy[i], board);
+    }
+    void solve(vector<vector<char>> &board)
+    {
+        n = board.size(), m = n ? board[0].size() : 0;
+        if (!(m & n))
+            return;
+        for (int i = 0; i < n; ++i)
+        {
+            if (board[i][0] == 'O')
+                dfs(i, 0, board);
+            if (board[i][m - 1] == 'O')
+                dfs(i, m - 1, board);
+        }
+        for (int j = 0; j < m; ++j)
+        {
+            if (board[0][j] == 'O')
+                dfs(0, j, board);
+            if (board[n - 1][j] == 'O')
+                dfs(n - 1, j, board);
+        }
+        for (int i = 0; i < n; ++i)
+            for (int j = 0; j < m; ++j)
+                if (board[i][j] == 'O')
+                    board[i][j] = 'X';
+                else if (board[i][j] == 'o')
+                    board[i][j] = 'O';
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/130_分割回文串/solution.cpp

+#include <vector>
+using std::vector;
+#include <string>
+using std::string;
+
+class Solution
+{
+    vector<vector<string>> ret;
+
+public:
+    using cIter = string::const_iterator;
+    vector<vector<string>> partition(string s)
+    {
+        vector<string> v;
+        partition(s.cbegin(), s.cend(), v);
+        return ret;
+    }
+    void partition(cIter beg, cIter end, vector<string> &v)
+    {
+        if (beg == end)
+        {
+            ret.push_back(v);
+            return;
+        }
+        for (auto it = beg; it != end; ++it)
+            if (isPalindrome(beg, it))
+            {
+                v.emplace_back(beg, std::next(it));
+                partition(std::next(it), end, v);
+                v.pop_back();
+            }
+    }
+    bool isPalindrome(cIter first, cIter last)
+    {
+        for (; first < last; ++first, --last)
+            if (*first != *last)
+                return false;
+        return true;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/131_分割回文串 II/solution.cpp

+class Solution
+{
+public:
+    int minCut(string s)
+    {
+        if (s.empty())
+            return 0;
+        int n = s.size();
+        vector<vector<bool>> p(n, vector<bool>(n));
+        vector<int> dp(n);
+        for (int i = 0; i < n; ++i)
+        {
+            dp[i] = i;
+            for (int j = 0; j <= i; ++j)
+            {
+                if (s[i] == s[j] && (i - j < 2 || p[j + 1][i - 1]))
+                {
+                    p[j][i] = true;
+                    dp[i] = (j == 0) ? 0 : min(dp[i], dp[j - 1] + 1);
+                }
+            }
+        }
+        return dp[n - 1];
+    }
+};

data/3.算法高阶/1.leetcode/132_克隆图/solution.cpp

+#include <vector>
+using std::vector;
+#include <unordered_map>
+using std::unordered_map;
+
+struct UndirectedGraphNode
+{
+    int label;
+    vector<UndirectedGraphNode *> neighbors;
+    UndirectedGraphNode(int x) : label(x){};
+};
+
+class Solution
+{
+    unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map;
+    void dfs(UndirectedGraphNode *node)
+    {
+        if (map.find(node) != map.end())
+            return;
+        map[node] = new UndirectedGraphNode(node->label);
+        for (UndirectedGraphNode *neighbor : node->neighbors)
+        {
+            dfs(neighbor);
+            map[node]->neighbors.push_back(map[neighbor]);
+        }
+    }
+
+public:
+    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node)
+    {
+        if (!node)
+            return node;
+        dfs(node);
+        return map[node];
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/133_加油站/solution.cpp

+#include <vector>
+using std::vector;
+
+class Solution
+{
+public:
+    int canCompleteCircuit(vector<int> &gas, vector<int> &cost)
+    {
+        int tank{0}, start{0}, stored{0};
+        for (decltype(gas.size()) i = 0; i < gas.size(); ++i)
+            if ((tank += gas[i] - cost[i]) < 0)
+            {
+                start = i + 1;
+                stored += tank;
+                tank = 0;
+            }
+        return (tank + stored) < 0 ? -1 : start;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/134_分发糖果/solution.cpp

+class Solution
+{
+public:
+    int candy(vector<int> &ratings)
+    {
+        int n = ratings.size();
+        int ans = 0;
+        vector<int> sum(n, 1);
+        if (n < 2)
+            return n;
+        for (int i = 0; i < n; ++i)
+        {
+            if (i > 0 && ratings[i] > ratings[i - 1])
+                sum[i] = sum[i - 1] + 1;
+        }
+        for (int i = n - 1; i >= 0; --i)
+        {
+            if (i < n - 1 && ratings[i] > ratings[i + 1])
+                sum[i] = max(sum[i + 1] + 1, sum[i]);
+            ans += sum[i];
+        }
+        return ans;
+    }
+};

data/3.算法高阶/1.leetcode/135_只出现一次的数字/solution.cpp

+class Solution
+{
+public:
+    int singleNumber(int A[], int n)
+    {
+        int r{0};
+        for (int i = 0; i != n; ++i)
+            r ^= A[i];
+        return r;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/136_只出现一次的数字 II/solution.cpp

+
+
+class Solution
+{
+public:
+    int singleNumber(int A[], int n)
+    {
+        int low = 0;
+        for (int i = 0, high = 0; i != n; ++i)
+        {
+            low ^= A[i] & ~high;
+            high ^= A[i] & ~low;
+        }
+        return low;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/137_复制带随机指针的链表/solution.cpp

+#include <cstddef>
+#include <unordered_map>
+
+struct RandomListNode
+{
+    int label;
+    RandomListNode *next, *random;
+    RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
+};
+
+class Solution
+{
+public:
+    RandomListNode *copyRandomList(RandomListNode *head)
+    {
+        std::unordered_map<RandomListNode *, RandomListNode *> map;
+        RandomListNode preHead(0);
+        for (RandomListNode *next = &preHead; head; next = next->next, head = head->next)
+        {
+            if (map[head] == NULL)
+            {
+                RandomListNode *node = new RandomListNode(head->label);
+                map[head] = node;
+            }
+            next->next = map[head];
+            if (head->random && map[head->random] == NULL)
+            {
+                RandomListNode *node = new RandomListNode(head->random->label);
+                map[head->random] = node;
+            }
+            map[head]->random = map[head->random];
+        }
+        return preHead.next;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1382_最大的团队表现值/desc.html

+<p>公司有编号为 <code>1</code>&nbsp;到 <code>n</code>&nbsp;的 <code>n</code>&nbsp;个工程师，给你两个数组 <code>speed</code>&nbsp;和 <code>efficiency</code>&nbsp;，其中 <code>speed[i]</code>&nbsp;和 <code>efficiency[i]</code>&nbsp;分别代表第 <code>i</code>&nbsp;位工程师的速度和效率。请你返回由最多&nbsp;<code>k</code>&nbsp;个工程师组成的&nbsp;<strong>​​​​​​最大团队表现值</strong>&nbsp;，由于答案可能很大，请你返回结果对 <code>10^9 + 7</code> 取余后的结果。</p>
+
+<p><strong>团队表现值</strong>&nbsp;的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
+<strong>输出：</strong>60
+<strong>解释：</strong>
+我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
+<strong>输出：</strong>68
+<strong>解释：
+</strong>此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
+<strong>输出：</strong>72
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10^5</code></li>
+	<li><code>speed.length == n</code></li>
+	<li><code>efficiency.length == n</code></li>
+	<li><code>1 &lt;= speed[i] &lt;= 10^5</code></li>
+	<li><code>1 &lt;= efficiency[i] &lt;= 10^8</code></li>
+	<li><code>1 &lt;= k &lt;= n</code></li>
+</ul>

data/3.算法高阶/1.leetcode/138_单词拆分/solution.cpp

+#include <string>
+using std::string;
+#include <unordered_set>
+using std::unordered_set;
+#include <vector>
+
+class Solution
+{
+public:
+    bool wordBreak(string s, unordered_set<string> &dict)
+    {
+        if (dict.find(s) != dict.end())
+            return true;
+        std::vector<string::const_iterator> cache{s.cbegin()};
+        for (auto subEnd = s.cbegin(); subEnd != s.cend(); ++subEnd)
+            for (auto subBeg : cache)
+                if (subBeg < subEnd && dict.find(string(subBeg, subEnd)) != dict.end())
+                {
+                    if (dict.find(string(subEnd, s.cend())) != dict.end())
+                        return true;
+                    cache.push_back(subEnd);
+                    break;
+                }
+        return false;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1396_找到所有好字符串/desc.html

+<p>给你两个长度为 <code>n</code>&nbsp;的字符串&nbsp;<code>s1</code> 和&nbsp;<code>s2</code>&nbsp;，以及一个字符串&nbsp;<code>evil</code>&nbsp;。请你返回 <strong>好字符串&nbsp;</strong>的数目。</p>
+
+<p><strong>好字符串</strong>&nbsp;的定义为：它的长度为&nbsp;<code>n</code>&nbsp;，字典序大于等于&nbsp;<code>s1</code>&nbsp;，字典序小于等于&nbsp;<code>s2</code>&nbsp;，且不包含&nbsp;<code>evil</code>&nbsp;为子字符串。</p>
+
+<p>由于答案可能很大，请你返回答案对 10^9 + 7 取余的结果。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 2, s1 = &quot;aa&quot;, s2 = &quot;da&quot;, evil = &quot;b&quot;
+<strong>输出：</strong>51 
+<strong>解释：</strong>总共有 25 个以 &#39;a&#39; 开头的好字符串：&quot;aa&quot;，&quot;ac&quot;，&quot;ad&quot;，...，&quot;az&quot;。还有 25 个以 &#39;c&#39; 开头的好字符串：&quot;ca&quot;，&quot;cc&quot;，&quot;cd&quot;，...，&quot;cz&quot;。最后，还有一个以 &#39;d&#39; 开头的好字符串：&quot;da&quot;。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 8, s1 = &quot;leetcode&quot;, s2 = &quot;leetgoes&quot;, evil = &quot;leet&quot;
+<strong>输出：</strong>0 
+<strong>解释：</strong>所有字典序大于等于 s1 且小于等于 s2 的字符串都以 evil 字符串 &quot;leet&quot; 开头。所以没有好字符串。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>n = 2, s1 = &quot;gx&quot;, s2 = &quot;gz&quot;, evil = &quot;x&quot;
+<strong>输出：</strong>2
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>s1.length == n</code></li>
+	<li><code>s2.length == n</code></li>
+	<li><code>s1 &lt;= s2</code></li>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+	<li><code>1 &lt;= evil.length &lt;= 50</code></li>
+	<li>所有字符串都只包含小写英文字母。</li>
+</ul>

data/3.算法高阶/1.leetcode/1398_统计最大组的数目/desc.html

+<p>给你一个整数 <code>n</code>&nbsp;。请你先求出从 <code>1</code>&nbsp;到 <code>n</code> 的每个整数 10 进制表示下的数位和（每一位上的数字相加），然后把数位和相等的数字放到同一个组中。</p>
+
+<p>请你统计每个组中的数字数目，并返回数字数目并列最多的组有多少个。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 13
+<strong>输出：</strong>4
+<strong>解释：</strong>总共有 9 个组，将 1 到 13 按数位求和后这些组分别是：
+[1,10]，[2,11]，[3,12]，[4,13]，[5]，[6]，[7]，[8]，[9]。总共有 4 个组拥有的数字并列最多。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 2
+<strong>输出：</strong>2
+<strong>解释：</strong>总共有 2 个大小为 1 的组 [1]，[2]。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>n = 15
+<strong>输出：</strong>6
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre><strong>输入：</strong>n = 24
+<strong>输出：</strong>5
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10^4</code></li>
+</ul>

data/3.算法高阶/1.leetcode/139_单词拆分 II/solution.cpp

+class Solution
+{
+public:
+    vector<string> wordBreak(string s, vector<string> &wordDict)
+    {
+        unordered_map<string, vector<string>> m;
+        return helper(s, wordDict, m);
+    }
+    vector<string> helper(string s, vector<string> &wordDict, unordered_map<string, vector<string>> &m)
+    {
+        if (m.count(s))
+            return m[s];
+        if (s.empty())
+            return {""};
+        vector<string> ans;
+        for (string word : wordDict)
+        {
+            if (word != s.substr(0, word.size()))
+                continue;
+            vector<string> res = helper(s.substr(word.size()), wordDict, m);
+            for (string str : res)
+            {
+                ans.push_back(word + (str.empty() ? "" : " ") + str);
+            }
+        }
+        return m[s] = ans;
+    }
+};

data/3.算法高阶/1.leetcode/140_环形链表/solution.cpp

+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    bool hasCycle(ListNode *head)
+    {
+        ListNode *low = head;   //慢指针
+        ListNode *quick = head; //快指针
+        while (low && quick && quick->next)
+        {
+            low = low->next;
+            quick = quick->next->next;
+            if (low == quick)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/1412_逐步求和得到正数的最小值/desc.html

+<p>给你一个整数数组 <code>nums</code>&nbsp;。你可以选定任意的&nbsp;<strong>正数</strong> startValue 作为初始值。</p>
+
+<p>你需要从左到右遍历 <code>nums</code>&nbsp;数组，并将 startValue 依次累加上&nbsp;<code>nums</code>&nbsp;数组中的值。</p>
+
+<p>请你在确保累加和始终大于等于 1 的前提下，选出一个最小的&nbsp;<strong>正数</strong>&nbsp;作为 startValue 。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [-3,2,-3,4,2]
+<strong>输出：</strong>5
+<strong>解释：</strong>如果你选择 startValue = 4，在第三次累加时，和小于 1 。
+<strong>                累加求和
+&nbsp;               startValue = 4 | startValue = 5 | nums
+</strong>&nbsp;                 (4 <strong>-3</strong> ) = 1  | (5 <strong>-3</strong> ) = 2    |  -3
+&nbsp;                 (1 <strong>+2</strong> ) = 3  | (2 <strong>+2</strong> ) = 4    |   2
+&nbsp;                 (3 <strong>-3</strong> ) = 0  | (4 <strong>-3</strong> ) = 1    |  -3
+&nbsp;                 (0 <strong>+4</strong> ) = 4  | (1 <strong>+4</strong> ) = 5    |   4
+&nbsp;                 (4 <strong>+2</strong> ) = 6  | (5 <strong>+2</strong> ) = 7    |   2
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [1,2]
+<strong>输出：</strong>1
+<strong>解释：</strong>最小的 startValue 需要是正数。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [1,-2,-3]
+<strong>输出：</strong>5
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums.length &lt;= 100</code></li>
+	<li><code>-100 &lt;= nums[i] &lt;= 100</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1413_和为 K 的最少斐波那契数字数目/desc.html

+<p>给你数字 <code>k</code>&nbsp;，请你返回和为&nbsp;<code>k</code>&nbsp;的斐波那契数字的最少数目，其中，每个斐波那契数字都可以被使用多次。</p>
+
+<p>斐波那契数字定义为：</p>
+
+<ul>
+	<li>F<sub>1</sub> = 1</li>
+	<li>F<sub>2</sub> = 1</li>
+	<li>F<sub>n</sub> = F<sub>n-1</sub> + F<sub>n-2</sub>&nbsp;， 其中 n &gt; 2 。</li>
+</ul>
+
+<p>数据保证对于给定的 <code>k</code>&nbsp;，一定能找到可行解。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>k = 7
+<strong>输出：</strong>2 
+<strong>解释：</strong>斐波那契数字为：1，1，2，3，5，8，13，&hellip;&hellip;
+对于 k = 7 ，我们可以得到 2 + 5 = 7 。</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>k = 10
+<strong>输出：</strong>2 
+<strong>解释：</strong>对于 k = 10 ，我们可以得到 2 + 8 = 10 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>k = 19
+<strong>输出：</strong>3 
+<strong>解释：</strong>对于 k = 19 ，我们可以得到 1 + 5 + 13 = 19 。
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;= 10^9</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1414_长度为 n 的开心字符串中字典序第 k 小的字符串/desc.html

+<p>一个 「开心字符串」定义为：</p>
+
+<ul>
+	<li>仅包含小写字母&nbsp;<code>[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]</code>.</li>
+	<li>对所有在&nbsp;<code>1</code>&nbsp;到&nbsp;<code>s.length - 1</code>&nbsp;之间的&nbsp;<code>i</code>&nbsp;，满足&nbsp;<code>s[i] != s[i + 1]</code>&nbsp;（字符串的下标从 1 开始）。</li>
+</ul>
+
+<p>比方说，字符串&nbsp;<strong>&quot;abc&quot;</strong>，<strong>&quot;ac&quot;，&quot;b&quot;</strong> 和&nbsp;<strong>&quot;abcbabcbcb&quot;</strong>&nbsp;都是开心字符串，但是&nbsp;<strong>&quot;aa&quot;</strong>，<strong>&quot;baa&quot;</strong>&nbsp;和&nbsp;<strong>&quot;ababbc&quot;</strong>&nbsp;都不是开心字符串。</p>
+
+<p>给你两个整数 <code>n</code>&nbsp;和 <code>k</code>&nbsp;，你需要将长度为 <code>n</code>&nbsp;的所有开心字符串按字典序排序。</p>
+
+<p>请你返回排序后的第 k 个开心字符串，如果长度为 <code>n</code>&nbsp;的开心字符串少于 <code>k</code>&nbsp;个，那么请你返回 <strong>空字符串</strong>&nbsp;。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>n = 1, k = 3
+<strong>输出：</strong>&quot;c&quot;
+<strong>解释：</strong>列表 [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;] 包含了所有长度为 1 的开心字符串。按照字典序排序后第三个字符串为 &quot;c&quot; 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>n = 1, k = 4
+<strong>输出：</strong>&quot;&quot;
+<strong>解释：</strong>长度为 1 的开心字符串只有 3 个。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>n = 3, k = 9
+<strong>输出：</strong>&quot;cab&quot;
+<strong>解释：</strong>长度为 3 的开心字符串总共有 12 个 [&quot;aba&quot;, &quot;abc&quot;, &quot;aca&quot;, &quot;acb&quot;, &quot;bab&quot;, &quot;bac&quot;, &quot;bca&quot;, &quot;bcb&quot;, &quot;cab&quot;, &quot;cac&quot;, &quot;cba&quot;, &quot;cbc&quot;] 。第 9 个字符串为 &quot;cab&quot;
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre><strong>输入：</strong>n = 2, k = 7
+<strong>输出：</strong>&quot;&quot;
+</pre>
+
+<p><strong>示例 5：</strong></p>
+
+<pre><strong>输入：</strong>n = 10, k = 100
+<strong>输出：</strong>&quot;abacbabacb&quot;
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10</code></li>
+	<li><code>1 &lt;= k &lt;= 100</code></li>
+</ul>
+
+<p>&nbsp;</p>

data/3.算法高阶/1.leetcode/1415_恢复数组/desc.html

+<p>某个程序本来应该输出一个整数数组。但是这个程序忘记输出空格了以致输出了一个数字字符串，我们所知道的信息只有：数组中所有整数都在 <code>[1, k]</code>&nbsp;之间，且数组中的数字都没有前导 0 。</p>
+
+<p>给你字符串&nbsp;<code>s</code>&nbsp;和整数&nbsp;<code>k</code>&nbsp;。可能会有多种不同的数组恢复结果。</p>
+
+<p>按照上述程序，请你返回所有可能输出字符串&nbsp;<code>s</code>&nbsp;的数组方案数。</p>
+
+<p>由于数组方案数可能会很大，请你返回它对&nbsp;<code>10^9 + 7</code>&nbsp;<strong>取余</strong>&nbsp;后的结果。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;1000&quot;, k = 10000
+<strong>输出：</strong>1
+<strong>解释：</strong>唯一一种可能的数组方案是 [1000]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;1000&quot;, k = 10
+<strong>输出：</strong>0
+<strong>解释：</strong>不存在任何数组方案满足所有整数都 &gt;= 1 且 &lt;= 10 同时输出结果为 s 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;1317&quot;, k = 2000
+<strong>输出：</strong>8
+<strong>解释：</strong>可行的数组方案为 [1317]，[131,7]，[13,17]，[1,317]，[13,1,7]，[1,31,7]，[1,3,17]，[1,3,1,7]
+</pre>
+
+<p><strong>示例 4：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;2020&quot;, k = 30
+<strong>输出：</strong>1
+<strong>解释：</strong>唯一可能的数组方案是 [20,20] 。 [2020] 不是可行的数组方案，原因是 2020 &gt; 30 。 [2,020] 也不是可行的数组方案，因为 020 含有前导 0 。
+</pre>
+
+<p><strong>示例 5：</strong></p>
+
+<pre><strong>输入：</strong>s = &quot;1234567890&quot;, k = 90
+<strong>输出：</strong>34
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 10^5</code>.</li>
+	<li><code>s</code>&nbsp;只包含数字且不包含前导 0 。</li>
+	<li><code>1 &lt;= k &lt;= 10^9</code>.</li>
+</ul>

data/3.算法高阶/1.leetcode/141_环形链表 II/solution.cpp

+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *detectCycle(ListNode *head)
+    {
+        ListNode *slow = head; //记录慢指针
+        ListNode *fast = head; //记录快指针
+        ListNode *meet = NULL; //记录相遇点
+        while (slow && fast && fast->next)
+        { //找出相遇点
+            slow = slow->next;
+            fast = fast->next->next;
+            if (slow == fast)
+            {
+                meet = slow;
+                break;
+            }
+        }
+        while (head && meet)
+        { //根据相遇的的位置找出环的入口点
+            if (meet == head)
+            {
+                break;
+            }
+            head = head->next;
+            meet = meet->next;
+        }
+        return meet;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/142_重排链表/solution.cpp

+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode() : val(0), next(nullptr) {}
+    ListNode(int x) : val(x), next(nullptr) {}
+    ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+
+//利用数组可以索引来做
+class Solution
+{
+public:
+    void reorderList(ListNode *head)
+    {
+        if (head == nullptr || head->next == nullptr || head->next->next == nullptr)
+            return;
+        ListNode *cur = head;
+        vector<ListNode *> vec;
+        while (cur)
+        {
+            // vec.push_back(cur);
+            vec.emplace_back(cur);
+            cur = cur->next;
+        }
+        int i = 0, j = vec.size() - 1;
+        while (i < j)
+        {
+            if (i == j)
+                break;
+            vec[i]->next = vec[j];
+            vec[j]->next = vec[i + 1];
+            i++;
+            j--;
+        }
+        vec[i]->next = nullptr;
+    }
+};

data/3.算法高阶/1.leetcode/143_二叉树的前序遍历/solution.cpp

+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+* /
+    class Solution
+{
+public:
+    vector<int> preorderTraversal(TreeNode *root)
+    {
+        //中前后
+        //非递归：栈
+        stack<TreeNode *> sta;
+        vector<int> ans;
+        while (root != NULL || !sta.empty())
+        {
+
+            while (root != NULL)
+            {
+                ans.push_back(root->val);
+                sta.push(root);
+                root = root->left;
+            }
+            if (!sta.empty())
+            {
+                root = sta.top();
+                sta.pop();
+                root = root->right;
+            }
+        }
+        return ans;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/144_二叉树的后序遍历/solution.cpp

+
+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    vector<int> postorderTraversal(TreeNode *root)
+    {
+        vector<int> ret;
+        if (root == NULL)
+            return ret;
+        TreeNode *p = root;
+        stack<TreeNode *> toTraversal;
+        TreeNode *last = root;
+        toTraversal.push(p);
+        while (!toTraversal.empty())
+        {
+            p = toTraversal.top();
+            if ((p->left == NULL && p->right == NULL) || (p->right == NULL && last == p->left) || (last == p->right))
+            {
+                ret.push_back(p->val);
+                last = p;
+                toTraversal.pop();
+            }
+            else
+            {
+                if (p->right)
+                    toTraversal.push(p->right);
+                if (p->left)
+                    toTraversal.push(p->left);
+            }
+        }
+
+        return ret;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/145_LRU 缓存机制/solution.cpp

+class LRUCache
+{
+public:
+    LRUCache(int capacity) : cap(capacity) {}
+
+    int get(int key)
+    {
+        if (m.count(key) != 0)
+        {
+            int val = m[key]->second;
+            l.erase(m[key]);
+            l.push_front({key, val}); //访问过的元素移动到头部
+            m[key] = l.begin();
+            return val;
+        }
+        return -1;
+    }
+
+    void put(int key, int value)
+    {
+        if (m.count(key) != 0)
+        { //已经存在
+            l.erase(m[key]);
+            l.push_front({key, value});
+            m[key] = l.begin();
+        }
+        else
+        {
+            if (l.size() == cap)
+            { //同步删除
+                m.erase(l.back().first);
+                l.pop_back();
+            }
+            l.push_front({key, value});
+            m[key] = l.begin();
+        }
+    }
+
+private:
+    int cap;
+    list<pair<int, int>> l;
+    unordered_map<int, list<pair<int, int>>::iterator> m;
+};

data/3.算法高阶/1.leetcode/146_对链表进行插入排序/solution.cpp

+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *insertionSortList(ListNode *head)
+    {
+        ListNode dummy(-1);
+        ListNode *prev = &dummy;
+        ListNode *curr = head;
+        while (curr)
+        {
+            ListNode *next = curr->next;
+            if (!prev->next || prev->next->val > curr->val)
+            {
+                prev = &dummy;
+            }
+
+            while (prev->next && prev->next->val <= curr->val)
+            {
+                prev = prev->next;
+            }
+
+            curr->next = prev->next;
+            prev->next = curr;
+            curr = next;
+        }
+
+        return dummy.next;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/147_排序链表/solution.cpp

+
+struct ListNode
+{
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(NULL) {}
+};
+
+class Solution
+{
+public:
+    ListNode *sortList(ListNode *head)
+    {
+        if (!head || !head->next)
+            return head;
+        ListNode *pre = head, *slow = head, *fast = head;
+        while (fast && fast->next)
+        {
+            pre = slow;
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+        pre->next = NULL;
+        return merge(sortList(head), sortList(slow));
+    }
+    ListNode *merge(ListNode *l1, ListNode *l2)
+    {
+        ListNode *dummy = new ListNode(-1);
+        ListNode *cur = dummy;
+        while (l1 && l2)
+        {
+            if (l1->val > l2->val)
+            {
+                cur->next = l2;
+                l2 = l2->next;
+            }
+            else
+            {
+                cur->next = l1;
+                l1 = l1->next;
+            }
+            cur = cur->next;
+        }
+        if (l1)
+            cur->next = l1;
+        if (l2)
+            cur->next = l2;
+        return dummy->next;
+    }
+};

data/3.算法高阶/1.leetcode/1482_树节点的第 K 个祖先/desc.html

+<p>给你一棵树，树上有 <code>n</code> 个节点，按从 <code>0</code> 到 <code>n-1</code> 编号。树以父节点数组的形式给出，其中 <code>parent[i]</code> 是节点 <code>i</code> 的父节点。树的根节点是编号为 <code>0</code> 的节点。</p>
+
+<p>请你设计并实现 <code>getKthAncestor</code><code>(int node, int k)</code> 函数，函数返回节点 <code>node</code> 的第 <code>k</code> 个祖先节点。如果不存在这样的祖先节点，返回 <code>-1</code> 。</p>
+
+<p>树节点的第 <em><code>k</code> </em>个祖先节点是从该节点到根节点路径上的第 <code>k</code> 个节点。</p>
+
+<p>&nbsp;</p>
+
+<p><strong>示例：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/06/14/1528_ex1.png" style="height: 262px; width: 396px;"></strong></p>
+
+<pre><strong>输入：</strong>
+[&quot;TreeAncestor&quot;,&quot;getKthAncestor&quot;,&quot;getKthAncestor&quot;,&quot;getKthAncestor&quot;]
+[[7,[-1,0,0,1,1,2,2]],[3,1],[5,2],[6,3]]
+
+<strong>输出：</strong>
+[null,1,0,-1]
+
+<strong>解释：</strong>
+TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);
+
+treeAncestor.getKthAncestor(3, 1);  // 返回 1 ，它是 3 的父节点
+treeAncestor.getKthAncestor(5, 2);  // 返回 0 ，它是 5 的祖父节点
+treeAncestor.getKthAncestor(6, 3);  // 返回 -1 因为不存在满足要求的祖先节点
+</pre>
+
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= k &lt;=&nbsp;n &lt;= 5*10^4</code></li>
+	<li><code>parent[0] == -1</code> 表示编号为 <code>0</code> 的节点是根节点。</li>
+	<li>对于所有的 <code>0 &lt;&nbsp;i &lt; n</code> ，<code>0 &lt;= parent[i] &lt; n</code> 总成立</li>
+	<li><code>0 &lt;= node &lt; n</code></li>
+	<li>至多查询 <code>5*10^4</code> 次</li>
+</ul>

data/3.算法高阶/1.leetcode/148_直线上最多的点数/solution.cpp

+
+
+struct Point
+{
+    int x;
+    int y;
+    Point() : x(0), y(0) {}
+    Point(int a, int b) : x(a), y(b) {}
+};
+
+class Solution
+{
+public:
+    int maxPoints(vector<Point> &points)
+    {
+        int ans = 0;
+        for (int i = 0; i < points.size(); ++i)
+        {
+            map<pair<int, int>, int> m;
+            int p = 1;
+            for (int j = i + 1; j < points.size(); ++j)
+            {
+                if (points[i].x == points[j].x && (points[i].y == points[j].y))
+                {
+                    ++p;
+                    continue;
+                }
+                int dx = points[j].x - points[i].x;
+                int dy = points[j].y - points[i].y;
+                int d = gcd(dx, dy);
+                ++m[{dx / d, dy / d}];
+            }
+            ans = max(ans, p);
+            for (auto it = m.begin(); it != m.end(); ++it)
+            {
+                ans = max(ans, it->second + p);
+            }
+        }
+        return ans;
+    }
+    int gcd(int a, int b)
+    {
+        return (b == 0) ? a : gcd(b, a % b);
+    }
+};

data/3.算法高阶/1.leetcode/149_逆波兰表达式求值/solution.cpp

+int evalRPN(vector<string> &tokens)
+{
+    stack<int> sp;
+    int n = tokens.size();
+    for (int i = 0; i < n; i++)
+    {
+        if (tokens[i] == "+")
+        {
+            int x = sp.top();
+            sp.pop();
+            int y = sp.top();
+            sp.pop();
+            sp.push(x + y);
+        }
+        else if (tokens[i] == "-")
+        {
+            int x = sp.top();
+            sp.pop();
+            int y = sp.top();
+            sp.pop();
+            sp.push(y - x);
+        }
+        else if (tokens[i] == "*")
+        {
+            int x = sp.top();
+            sp.pop();
+            int y = sp.top();
+            sp.pop();
+            sp.push(x * y);
+        }
+        else if (tokens[i] == "/")
+        {
+            int x = sp.top();
+            sp.pop();
+            int y = sp.top();
+            sp.pop();
+            sp.push(y / x);
+        }
+        else
+        {
+            sp.push(stoi(tokens[i]));
+        }
+    }
+    return sp.top();
+}

data/3.算法高阶/1.leetcode/150_翻转字符串里的单词/solution.cpp

+class Solution
+{
+public:
+    void reverseWords(string &s)
+    {
+        if (s.empty())
+            return;
+        vector<string> words;
+        auto p1 = s.begin(), p2 = s.begin(), p3 = s.end();
+        while (p2 != p3)
+        {
+            while (' ' == *p1 && p1 != p3)
+            {
+                ++p1;
+            }
+            p2 = p1;
+            while (' ' != *p2 && p2 != p3)
+                ++p2;
+            if (p1 != p3)
+                words.push_back(string(p1, p2));
+            p1 = p2;
+        }
+        reverse(words.begin(), words.end());
+        s.clear();
+        for (int i = 0; i < words.size(); ++i)
+        {
+            if (1 == words.size())
+                s = words[i];
+            else if (i == words.size() - 1)
+                s += words[i];
+            else
+                s += words[i] + ' ';
+        }
+    }
+};

data/3.算法高阶/1.leetcode/151_乘积最大子数组/solution.cpp

+class Solution
+{
+public:
+    int maxProduct(vector<int> &nums)
+    {
+        int n = nums.size(), res = nums[0];
+        vector<int> f(n + 1, 0), g(n + 1, 0);
+        f[0] = nums[0], g[0] = nums[0]; // 初始化
+        for (int i = 1; i < n; i++)
+        {
+            f[i] = max(nums[i], max(f[i - 1] * nums[i], g[i - 1] * nums[i])); //乘积最大值
+            g[i] = min(nums[i], min(g[i - 1] * nums[i], f[i - 1] * nums[i])); //乘积最小值
+            res = max(res, f[i]);
+        }
+        return res;
+    }
+};

data/3.算法高阶/1.leetcode/152_寻找旋转排序数组中的最小值/solution.cpp

+class Solution
+{
+public:
+    int findMin(vector<int> &nums)
+    {
+        int ans, n = nums.size();
+        int l = 0, r = n - 1;
+        if (nums[l] > nums[r])
+        {
+            while (l != (r - 1))
+            {
+                int mid = (l + r) / 2;
+                if (nums[mid] > nums[l])
+                    l = mid;
+                else
+                    r = mid;
+            }
+            return min(nums[l], nums[r]);
+        }
+        return nums[0];
+    }
+};

data/3.算法高阶/1.leetcode/153_寻找旋转排序数组中的最小值 II/solution.cpp

+class Solution
+{
+public:
+    int findMin(vector<int> &nums)
+    {
+        int size = nums.size();
+        if (size == 1)
+            return nums[0];
+        if (nums[0] < nums[size - 1])
+            return nums[0];
+        data = nums;
+        return find(0, size - 1);
+    }
+    int find(int first, int second)
+    { //闭区间
+        if (first == second)
+            return data[second];
+        if (first + 1 == second)
+            return data[second];
+        int min = data[second];
+        int mid = data[(first + second) / 2];
+        if (mid == min)
+        {
+            int sgn1 = find((first + second) / 2, second);
+            int sgn2 = find(first, (first + second) / 2);
+            return (sgn1 < sgn2 ? sgn1 : sgn2);
+        }
+        if (mid > min)
+            return find((first + second) / 2, second);
+        if (mid < min)
+            return find(first, (first + second) / 2);
+    }
+
+private:
+    vector<int> data;
+};

data/3.算法高阶/1.leetcode/154_最小栈/solution.cpp

+class MinStack
+{
+private:
+    stack<int> s1;
+    stack<int> s2;
+
+public:
+    void push(int x)
+    {
+        s1.push(x);
+        if (s2.empty() || x <= getMin())
+            s2.push(x);
+    }
+    void pop()
+    {
+        //在这里判断一下就是s2最小栈 二个栈中栈顶元素相同最小栈中的元素才会出栈;
+        if (s1.top() == getMin())
+            s2.pop();
+        s1.pop();
+    }
+    int top()
+    {
+        return s1.top();
+    }
+    int getMin()
+    {
+        return s2.top();
+    }
+};

data/3.算法高阶/1.leetcode/155_上下翻转二叉树/solution.cpp

+
+struct TreeNode
+{
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution
+{
+public:
+    TreeNode *upsideDownBinaryTree(TreeNode *root)
+    {
+        if (!root || !root->left)
+            return root;
+        TreeNode *l = root->left; //左右子节点存取来
+        TreeNode *r = root->right;
+        root->left = NULL; //上下断开
+        root->right = NULL;
+        TreeNode *p = upsideDownBinaryTree(l); //根节点
+        l->left = r;                           //跟上面连接起来
+        l->right = root;
+        return p;
+    }
+};

data/3.算法高阶/1.leetcode/156_用 Read4 读取 N 个字符/solution.cpp

+// Forward declaration of the read4 API.
+int read4(char *buf);
+
+class Solution
+{
+public:
+    /**
+     * @param buf Destination buffer
+     * @param n   Number of characters to read
+     * @return    The number of actual characters read
+     */
+    int read(char *buf, int n)
+    {
+        int total = 0;
+        while (1)
+        {
+            int ret = read4(buf + total);
+            total += ret;
+            if (ret < 4 || total >= n)
+                break;
+        }
+        if (total > n)
+            total = n;
+        buf[total] = '\0';
+        return total;
+    }
+};
\ No newline at end of file

data/3.算法高阶/1.leetcode/157_用 Read4 读取 N 个字符 II/solution.cpp

+
+int read4(char *buf);
+
+class Solution
+{
+    queue<char> q; //一次读取4个，可能多了，存储起来
+public:
+    /**
+     * @param buf Destination buffer
+     * @param n   Number of characters to read
+     * @return    The number of actual characters read
+     */
+    int read(char *buf, int n)
+    {
+        if (!buf || n <= 0)
+            return 0;
+        int len = 0, total = 0;
+        int offset = 0;
+        while (!q.empty()) //临时存储区还有先用掉
+        {
+            buf[offset++] = q.front();
+            q.pop();
+            total++;
+            if (offset == n) //个数到了
+                return n;
+        }
+        do
+        {
+            len = read4(buf + offset); //读取了len个有效字符，写入offset位置
+            total += len;
+            offset += len;
+        } while (len == 4 && len < n);
+
+        if (total > n)
+        { //读取多了，存到临时存储区
+            for (int i = n; i < total; i++)
+                q.push(buf[i]);
+        }
+        return min(n, total);
+    }
+};

data/3.算法高阶/1.leetcode/1704_吃苹果的最大数目/desc.html

+<p>有一棵特殊的苹果树，一连 <code>n</code> 天，每天都可以长出若干个苹果。在第 <code>i</code> 天，树上会长出 <code>apples[i]</code> 个苹果，这些苹果将会在 <code>days[i]</code> 天后（也就是说，第 <code>i + days[i]</code> 天时）腐烂，变得无法食用。也可能有那么几天，树上不会长出新的苹果，此时用 <code>apples[i] == 0</code> 且 <code>days[i] == 0</code> 表示。</p>
+
+<p>你打算每天 <strong>最多</strong> 吃一个苹果来保证营养均衡。注意，你可以在这 <code>n</code> 天之后继续吃苹果。</p>
+
+<p>给你两个长度为 <code>n</code> 的整数数组 <code>days</code> 和 <code>apples</code> ，返回你可以吃掉的苹果的最大数目<em>。</em></p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>apples = [1,2,3,5,2], days = [3,2,1,4,2]
+<strong>输出：</strong>7
+<strong>解释：</strong>你可以吃掉 7 个苹果：
+- 第一天，你吃掉第一天长出来的苹果。
+- 第二天，你吃掉一个第二天长出来的苹果。
+- 第三天，你吃掉一个第二天长出来的苹果。过了这一天，第三天长出来的苹果就已经腐烂了。
+- 第四天到第七天，你吃的都是第四天长出来的苹果。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]
+<strong>输出：</strong>5
+<strong>解释：</strong>你可以吃掉 5 个苹果：
+- 第一天到第三天，你吃的都是第一天长出来的苹果。
+- 第四天和第五天不吃苹果。
+- 第六天和第七天，你吃的都是第六天长出来的苹果。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>apples.length == n</code></li>
+	<li><code>days.length == n</code></li>
+	<li><code>1 &lt;= n &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>0 &lt;= apples[i], days[i] &lt;= 2 * 10<sup>4</sup></code></li>
+	<li>只有在 <code>apples[i] = 0</code> 时，<code>days[i] = 0</code> 才成立</li>
+</ul>

data/3.算法高阶/1.leetcode/1709_卡车上的最大单元数/desc.html

+<p>请你将一些箱子装在 <strong>一辆卡车</strong> 上。给你一个二维数组 <code>boxTypes</code> ，其中 <code>boxTypes[i] = [numberOfBoxes<sub>i</sub>, numberOfUnitsPerBox<sub>i</sub>]</code> ：</p>
+
+<ul>
+	<li><code>numberOfBoxes<sub>i</sub></code> 是类型 <code>i</code> 的箱子的数量。</li>
+	<li><code>numberOfUnitsPerBox<sub>i</sub></code><sub> </sub>是类型 <code>i</code> 每个箱子可以装载的单元数量。</li>
+</ul>
+
+<p>整数 <code>truckSize</code> 表示卡车上可以装载 <strong>箱子</strong> 的 <strong>最大数量</strong> 。只要箱子数量不超过 <code>truckSize</code> ，你就可以选择任意箱子装到卡车上。</p>
+
+<p>返回卡车可以装载 <strong>单元</strong> 的 <strong>最大</strong> 总数<em>。</em></p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
+<strong>输出：</strong>8
+<strong>解释：</strong>箱子的情况如下：
+- 1 个第一类的箱子，里面含 3 个单元。
+- 2 个第二类的箱子，每个里面含 2 个单元。
+- 3 个第三类的箱子，每个里面含 1 个单元。
+可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
+单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
+<strong>输出：</strong>91
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= boxTypes.length <= 1000</code></li>
+	<li><code>1 <= numberOfBoxes<sub>i</sub>, numberOfUnitsPerBox<sub>i</sub> <= 1000</code></li>
+	<li><code>1 <= truckSize <= 10<sup>6</sup></code></li>
+</ul>

data/3.算法高阶/1.leetcode/1712_得到子序列的最少操作次数/desc.html

+<p>给你一个数组 <code>target</code> ，包含若干 <strong>互不相同</strong> 的整数，以及另一个整数数组 <code>arr</code> ，<code>arr</code> <strong>可能</strong> 包含重复元素。</p>
+
+<p>每一次操作中，你可以在 <code>arr</code> 的任意位置插入任一整数。比方说，如果 <code>arr = [1,4,1,2]</code> ，那么你可以在中间添加 <code>3</code> 得到 <code>[1,4,<strong>3</strong>,1,2]</code> 。你可以在数组最开始或最后面添加整数。</p>
+
+<p>请你返回 <strong>最少</strong> 操作次数，使得<em> </em><code>target</code><em> </em>成为 <code>arr</code> 的一个子序列。</p>
+
+<p>一个数组的 <strong>子序列</strong> 指的是删除原数组的某些元素（可能一个元素都不删除），同时不改变其余元素的相对顺序得到的数组。比方说，<code>[2,7,4]</code> 是 <code>[4,<strong>2</strong>,3,<strong>7</strong>,2,1,<strong>4</strong>]</code> 的子序列（加粗元素），但 <code>[2,4,2]</code> 不是子序列。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><b>输入：</b>target = [5,1,3], <code>arr</code> = [9,4,2,3,4]
+<b>输出：</b>2
+<b>解释：</b>你可以添加 5 和 1 ，使得 arr 变为 [<strong>5</strong>,9,4,<strong>1</strong>,2,3,4] ，target 为 arr 的子序列。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><b>输入：</b>target = [6,4,8,1,3,2], <code>arr</code> = [4,7,6,2,3,8,6,1]
+<b>输出：</b>3
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 &lt;= target.length, arr.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= target[i], arr[i] &lt;= 10<sup>9</sup></code></li>
+	<li><code>target</code> 不包含任何重复元素。</li>
+</ul>

data/3.算法高阶/1.leetcode/1719_解码异或后的数组/desc.html

+<p><strong>未知</strong> 整数数组 <code>arr</code> 由 <code>n</code> 个非负整数组成。</p>
+
+<p>经编码后变为长度为 <code>n - 1</code> 的另一个整数数组 <code>encoded</code> ，其中 <code>encoded[i] = arr[i] XOR arr[i + 1]</code> 。例如，<code>arr = [1,0,2,1]</code> 经编码后得到 <code>encoded = [1,2,3]</code> 。</p>
+
+<p>给你编码后的数组 <code>encoded</code> 和原数组 <code>arr</code> 的第一个元素 <code>first</code>（<code>arr[0]</code>）。</p>
+
+<p>请解码返回原数组 <code>arr</code> 。可以证明答案存在并且是唯一的。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>encoded = [1,2,3], first = 1
+<strong>输出：</strong>[1,0,2,1]
+<strong>解释：</strong>若 arr = [1,0,2,1] ，那么 first = 1 且 encoded = [1 XOR 0, 0 XOR 2, 2 XOR 1] = [1,2,3]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>encoded = [6,2,7,3], first = 4
+<strong>输出：</strong>[4,2,0,7,4]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 <= n <= 10<sup>4</sup></code></li>
+	<li><code>encoded.length == n - 1</code></li>
+	<li><code>0 <= encoded[i] <= 10<sup>5</sup></code></li>
+	<li><code>0 <= first <= 10<sup>5</sup></code></li>
+</ul>

data/3.算法高阶/1.leetcode/1721_执行交换操作后的最小汉明距离/desc.html

+<p>给你两个整数数组 <code>source</code> 和 <code>target</code> ，长度都是 <code>n</code> 。还有一个数组 <code>allowedSwaps</code> ，其中每个 <code>allowedSwaps[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 表示你可以交换数组 <code>source</code> 中下标为 <code>a<sub>i</sub></code> 和 <code>b<sub>i</sub></code>（<strong>下标从 0 开始</strong>）的两个元素。注意，你可以按 <strong>任意</strong> 顺序 <strong>多次</strong> 交换一对特定下标指向的元素。</p>
+
+<p>相同长度的两个数组 <code>source</code> 和 <code>target</code> 间的 <strong>汉明距离</strong> 是元素不同的下标数量。形式上，其值等于满足 <code>source[i] != target[i]</code> （<strong>下标从 0 开始</strong>）的下标 <code>i</code>（<code>0 &lt;= i &lt;= n-1</code>）的数量。</p>
+
+<p>在对数组 <code>source</code> 执行 <strong>任意</strong> 数量的交换操作后，返回 <code>source</code> 和 <code>target</code> 间的 <strong>最小汉明距离</strong> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><strong>输入：</strong>source = [1,2,3,4], target = [2,1,4,5], allowedSwaps = [[0,1],[2,3]]
+<strong>输出：</strong>1
+<strong>解释：</strong>source 可以按下述方式转换：
+- 交换下标 0 和 1 指向的元素：source = [<strong>2</strong>,<strong>1</strong>,3,4]
+- 交换下标 2 和 3 指向的元素：source = [2,1,<strong>4</strong>,<strong>3</strong>]
+source 和 target 间的汉明距离是 1 ，二者有 1 处元素不同，在下标 3 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><strong>输入：</strong>source = [1,2,3,4], target = [1,3,2,4], allowedSwaps = []
+<strong>输出：</strong>2
+<strong>解释：</strong>不能对 source 执行交换操作。
+source 和 target 间的汉明距离是 2 ，二者有 2 处元素不同，在下标 1 和下标 2 。</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre><strong>输入：</strong>source = [5,1,2,4,3], target = [1,5,4,2,3], allowedSwaps = [[0,4],[4,2],[1,3],[1,4]]
+<strong>输出：</strong>0
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == source.length == target.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= source[i], target[i] &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= allowedSwaps.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>allowedSwaps[i].length == 2</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt;= n - 1</code></li>
+	<li><code>a<sub>i</sub> != b<sub>i</sub></code></li>
+</ul>

data/3.算法高阶/1.leetcode/1722_完成所有工作的最短时间/desc.html

+<p>给你一个整数数组 <code>jobs</code> ，其中 <code>jobs[i]</code> 是完成第 <code>i</code> 项工作要花费的时间。</p>
+
+<p>请你将这些工作分配给 <code>k</code> 位工人。所有工作都应该分配给工人，且每项工作只能分配给一位工人。工人的 <strong>工作时间</strong> 是完成分配给他们的所有工作花费时间的总和。请你设计一套最佳的工作分配方案，使工人的 <strong>最大工作时间</strong> 得以 <strong>最小化</strong> 。</p>
+
+<p>返回分配方案中尽可能 <strong>最小</strong> 的 <strong>最大工作时间</strong> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>jobs = [3,2,3], k = 3
+<strong>输出：</strong>3
+<strong>解释：</strong>给每位工人分配一项工作，最大工作时间是 3 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>jobs = [1,2,4,7,8], k = 2
+<strong>输出：</strong>11
+<strong>解释：</strong>按下述方式分配工作：
+1 号工人：1、2、8（工作时间 = 1 + 2 + 8 = 11）
+2 号工人：4、7（工作时间 = 4 + 7 = 11）
+最大工作时间是 11 。</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= k <= jobs.length <= 12</code></li>
+	<li><code>1 <= jobs[i] <= 10<sup>7</sup></code></li>
+</ul>

data/3.算法高阶/1.leetcode/1731_找到最高海拔/desc.html

+<p>有一个自行车手打算进行一场公路骑行，这条路线总共由 <code>n + 1</code> 个不同海拔的点组成。自行车手从海拔为 <code>0</code> 的点 <code>0</code> 开始骑行。</p>
+
+<p>给你一个长度为 <code>n</code> 的整数数组 <code>gain</code> ，其中 <code>gain[i]</code> 是点 <code>i</code> 和点 <code>i + 1</code> 的 <strong>净海拔高度差</strong>（<code>0 <= i < n</code>）。请你返回 <strong>最高点的海拔</strong> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<b>输入：</b>gain = [-5,1,5,0,-7]
+<b>输出：</b>1
+<b>解释：</b>海拔高度依次为 [0,-5,-4,1,1,-6] 。最高海拔为 1 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<b>输入：</b>gain = [-4,-3,-2,-1,4,3,2]
+<b>输出：</b>0
+<b>解释：</b>海拔高度依次为 [0,-4,-7,-9,-10,-6,-3,-1] 。最高海拔为 0 。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == gain.length</code></li>
+	<li><code>1 <= n <= 100</code></li>
+	<li><code>-100 <= gain[i] <= 100</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1732_需要教语言的最少人数/desc.html

+<p>在一个由 <code>m</code> 个用户组成的社交网络里，我们获取到一些用户之间的好友关系。两个用户之间可以相互沟通的条件是他们都掌握同一门语言。</p>
+
+<p>给你一个整数 <code>n</code> ，数组 <code>languages</code> 和数组 <code>friendships</code> ，它们的含义如下：</p>
+
+<ul>
+	<li>总共有 <code>n</code> 种语言，编号从 <code>1</code> 到 <code>n</code> 。</li>
+	<li><code>languages[i]</code> 是第 <code>i</code> 位用户掌握的语言集合。</li>
+	<li><code>friendships[i] = [u<sub>​​​​​​i</sub>​​​, v<sub>​​​​​​i</sub>]</code> 表示 <code>u<sup>​​​​​</sup><sub>​​​​​​i</sub></code>​​​​​ 和 <code>v<sub>i</sub></code> 为好友关系。</li>
+</ul>
+
+<p>你可以选择 <strong>一门</strong> 语言并教会一些用户，使得所有好友之间都可以相互沟通。请返回你 <strong>最少</strong> 需要教会多少名用户。</p>
+请注意，好友关系没有传递性，也就是说如果 <code>x</code> 和 <code>y</code> 是好友，且 <code>y</code> 和 <code>z</code> 是好友， <code>x</code> 和 <code>z</code> 不一定是好友。
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<b>输入：</b>n = 2, languages = [[1],[2],[1,2]], friendships = [[1,2],[1,3],[2,3]]
+<b>输出：</b>1
+<b>解释：</b>你可以选择教用户 1 第二门语言，也可以选择教用户 2 第一门语言。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<b>输入：</b>n = 3, languages = [[2],[1,3],[1,2],[3]], friendships = [[1,4],[1,2],[3,4],[2,3]]
+<b>输出：</b>2
+<b>解释：</b>教用户 1 和用户 3 第三门语言，需要教 2 名用户。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 <= n <= 500</code></li>
+	<li><code>languages.length == m</code></li>
+	<li><code>1 <= m <= 500</code></li>
+	<li><code>1 <= languages[i].length <= n</code></li>
+	<li><code>1 <= languages[i][j] <= n</code></li>
+	<li><code>1 <= u<sub>​​​​​​i</sub> < v<sub>​​​​​​i</sub> <= languages.length</code></li>
+	<li><code>1 <= friendships.length <= 500</code></li>
+	<li>所有的好友关系 <code>(u<sub>​​​​​i, </sub>v<sub>​​​​​​i</sub>)</code> 都是唯一的。</li>
+	<li><code>languages[i]</code> 中包含的值互不相同。</li>
+</ul>

data/3.算法高阶/1.leetcode/1733_解码异或后的排列/desc.html

+<p>给你一个整数数组 <code>perm</code> ，它是前 <code>n</code> 个正整数的排列，且 <code>n</code> 是个 <strong>奇数</strong> 。</p>
+
+<p>它被加密成另一个长度为 <code>n - 1</code> 的整数数组 <code>encoded</code> ，满足 <code>encoded[i] = perm[i] XOR perm[i + 1]</code> 。比方说，如果 <code>perm = [1,3,2]</code> ，那么 <code>encoded = [2,1]</code> 。</p>
+
+<p>给你 <code>encoded</code> 数组，请你返回原始数组 <code>perm</code> 。题目保证答案存在且唯一。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre><b>输入：</b>encoded = [3,1]
+<b>输出：</b>[1,2,3]
+<b>解释：</b>如果 perm = [1,2,3] ，那么 encoded = [1 XOR 2,2 XOR 3] = [3,1]
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre><b>输入：</b>encoded = [6,5,4,6]
+<b>输出：</b>[2,4,1,5,3]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>3 &lt;= n &lt; 10<sup>5</sup></code></li>
+	<li><code>n</code> 是奇数。</li>
+	<li><code>encoded.length == n - 1</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1818_序列中不同最大公约数的数目/desc.html

+<p>给你一个由正整数组成的数组 <code>nums</code> 。</p>
+
+<p>数字序列的 <strong>最大公约数</strong> 定义为序列中所有整数的共有约数中的最大整数。</p>
+
+<ul>
+	<li>例如，序列 <code>[4,6,16]</code> 的最大公约数是 <code>2</code> 。</li>
+</ul>
+
+<p>数组的一个 <strong>子序列</strong> 本质是一个序列，可以通过删除数组中的某些元素（或者不删除）得到。</p>
+
+<ul>
+	<li>例如，<code>[2,5,10]</code> 是 <code>[1,2,1,<strong>2</strong>,4,1,<strong>5</strong>,<strong>10</strong>]</code> 的一个子序列。</li>
+</ul>
+
+<p>计算并返回 <code>nums</code> 的所有 <strong>非空</strong> 子序列中 <strong>不同</strong> 最大公约数的 <strong>数目</strong> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/04/03/image-1.png" />
+<pre>
+<strong>输入：</strong>nums = [6,10,3]
+<strong>输出：</strong>5
+<strong>解释：</strong>上图显示了所有的非空子序列与各自的最大公约数。
+不同的最大公约数为 6 、10 、3 、2 和 1 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [5,15,40,5,6]
+<strong>输出：</strong>7
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
+	<li><code>1 <= nums[i] <= 2 * 10<sup>5</sup></code></li>
+</ul>

data/3.算法高阶/1.leetcode/1900_找出顶峰元素 II/desc.html

+<p>一个 2D 网格中的 <strong>顶峰元素 </strong>是指那些 <strong>严格大于 </strong>其相邻格子(上、下、左、右)的元素。</p>
+
+<p>给你一个<strong> 从 0 开始编号 </strong>的 <code>m x n</code> 矩阵 <code>mat</code> ，其中任意两个相邻格子的值都<strong> 不相同</strong> 。找出 <strong>任意一个 </strong>顶峰元素 <code>mat[i][j]</code> 并 <strong>返回其位置 </strong><code>[i,j]</code> 。</p>
+
+<p>你可以假设整个矩阵周边环绕着一圈值为 <code>-1</code> 的格子。</p>
+
+<p>要求必须写出时间复杂度为 <code>O(m log(n))</code> 或 <code>O(n log(m))</code> 的算法</p>
+
+<p> </p>
+
+<p> </p>
+
+<p><strong>示例 1:</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/1.png" style="width: 206px; height: 209px;" /></p>
+
+<pre>
+<strong>输入:</strong> mat = [[1,4],[3,2]]
+<strong>输出:</strong> [0,1]
+<strong>解释:</strong> 3和4都是顶峰元素，所以[1,0]和[0,1]都是可接受的答案。
+</pre>
+
+<p><strong>示例 2:</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2021/06/07/3.png" style="width: 254px; height: 257px;" /></strong></p>
+
+<pre>
+<strong>输入:</strong> mat = [[10,20,15],[21,30,14],[7,16,32]]
+<strong>输出:</strong> [1,1]
+<strong>解释:</strong> 30和32都是顶峰元素，所以[1,1]和[2,2]都是可接受的答案。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>m == mat.length</code></li>
+	<li><code>n == mat[i].length</code></li>
+	<li><code>1 <= m, n <= 500</code></li>
+	<li><code>1 <= mat[i][j] <= 10<sup>5</sup></code></li>
+	<li>任意两个相邻元素均不相等.</li>
+</ul>

data/3.算法高阶/1.leetcode/1913_循环轮转矩阵/desc.html

+<p>给你一个大小为 <code>m x n</code> 的整数矩阵 <code>grid</code>​​​ ，其中 <code>m</code> 和 <code>n</code> 都是 <strong>偶数</strong> ；另给你一个整数 <code>k</code> 。</p>
+
+<p>矩阵由若干层组成，如下图所示，每种颜色代表一层：</p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/06/10/ringofgrid.png" style="width: 231px; height: 258px;"></p>
+
+<p>矩阵的循环轮转是通过分别循环轮转矩阵中的每一层完成的。在对某一层进行一次循环旋转操作时，层中的每一个元素将会取代其 <strong>逆时针 </strong>方向的相邻元素。轮转示例如下：</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/22/explanation_grid.jpg" style="width: 500px; height: 268px;">
+<p>返回执行 <code>k</code> 次循环轮转操作后的矩阵。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/19/rod2.png" style="width: 421px; height: 191px;">
+<pre><strong>输入：</strong>grid = [[40,10],[30,20]], k = 1
+<strong>输出：</strong>[[10,20],[40,30]]
+<strong>解释：</strong>上图展示了矩阵在执行循环轮转操作时每一步的状态。</pre>
+
+<p><strong>示例 2：</strong></p>
+<strong><img alt="" src="https://assets.leetcode.com/uploads/2021/06/10/ringofgrid5.png" style="width: 231px; height: 262px;"></strong> <strong><img alt="" src="https://assets.leetcode.com/uploads/2021/06/10/ringofgrid6.png" style="width: 231px; height: 262px;"></strong> <strong><img alt="" src="https://assets.leetcode.com/uploads/2021/06/10/ringofgrid7.png" style="width: 231px; height: 262px;"></strong>
+
+<pre><strong>输入：</strong>grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], k = 2
+<strong>输出：</strong>[[3,4,8,12],[2,11,10,16],[1,7,6,15],[5,9,13,14]]
+<strong>解释：</strong>上图展示了矩阵在执行循环轮转操作时每一步的状态。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>2 &lt;= m, n &lt;= 50</code></li>
+	<li><code>m</code> 和 <code>n</code> 都是 <strong>偶数</strong></li>
+	<li><code>1 &lt;= grid[i][j] &lt;=<sup> </sup>5000</code></li>
+	<li><code>1 &lt;= k &lt;= 10<sup>9</sup></code></li>
+</ul>

data/3.算法高阶/1.leetcode/1914_最美子字符串的数目/desc.html

+<p>如果某个字符串中 <strong>至多一个</strong> 字母出现 <strong>奇数</strong> 次，则称其为 <strong>最美</strong> 字符串。</p>
+
+<ul>
+	<li>例如，<code>"ccjjc"</code> 和 <code>"abab"</code> 都是最美字符串，但 <code>"ab"</code> 不是。</li>
+</ul>
+
+<p>给你一个字符串 <code>word</code> ，该字符串由前十个小写英文字母组成（<code>'a'</code> 到 <code>'j'</code>）。请你返回 <code>word</code> 中 <strong>最美非空子字符串</strong> 的数目<em>。</em>如果同样的子字符串在<em> </em><code>word</code> 中出现多次，那么应当对 <strong>每次出现</strong> 分别计数<em>。</em></p>
+
+<p><strong>子字符串</strong> 是字符串中的一个连续字符序列。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>word = "aba"
+<strong>输出：</strong>4
+<strong>解释：</strong>4 个最美子字符串如下所示：
+- "<strong>a</strong>ba" -> "a"
+- "a<strong>b</strong>a" -> "b"
+- "ab<strong>a</strong>" -> "a"
+- "<strong>aba</strong>" -> "aba"
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>word = "aabb"
+<strong>输出：</strong>9
+<strong>解释：</strong>9 个最美子字符串如下所示：
+- "<strong>a</strong>abb" -> "a"
+- "<strong>aa</strong>bb" -> "aa"
+- "<strong>aab</strong>b" -> "aab"
+- "<strong>aabb</strong>" -> "aabb"
+- "a<strong>a</strong>bb" -> "a"
+- "a<strong>abb</strong>" -> "abb"
+- "aa<strong>b</strong>b" -> "b"
+- "aa<strong>bb</strong>" -> "bb"
+- "aab<strong>b</strong>" -> "b"
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>word = "he"
+<strong>输出：</strong>2
+<strong>解释：</strong>2 个最美子字符串如下所示：
+- "<b>h</b>e" -> "h"
+- "h<strong>e</strong>" -> "e"
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= word.length <= 10<sup>5</sup></code></li>
+	<li><code>word</code> 由从 <code>'a'</code> 到 <code>'j'</code> 的小写英文字母组成</li>
+</ul>

data/3.算法高阶/1.leetcode/1922_最长公共子路径/desc.html

+<p>一个国家由 <code>n</code> 个编号为 <code>0</code> 到 <code>n - 1</code> 的城市组成。在这个国家里，<strong>每两个</strong> 城市之间都有一条道路连接。</p>
+
+<p>总共有 <code>m</code> 个编号为 <code>0</code> 到 <code>m - 1</code> 的朋友想在这个国家旅游。他们每一个人的路径都会包含一些城市。每条路径都由一个整数数组表示，每个整数数组表示一个朋友按顺序访问过的城市序列。同一个城市在一条路径中可能 <strong>重复</strong> 出现，但同一个城市在一条路径中不会连续出现。</p>
+
+<p>给你一个整数 <code>n</code> 和二维数组 <code>paths</code> ，其中 <code>paths[i]</code> 是一个整数数组，表示第 <code>i</code> 个朋友走过的路径，请你返回 <strong>每一个</strong> 朋友都走过的 <strong>最长公共子路径</strong> 的长度，如果不存在公共子路径，请你返回 <code>0</code> 。</p>
+
+<p>一个 <strong>子路径</strong> 指的是一条路径中连续的城市序列。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<b>输入：</b>n = 5, paths = [[0,1,<strong>2,3</strong>,4],
+                     [<strong>2,3</strong>,4],
+                     [4,0,1,<strong>2,3</strong>]]
+<b>输出：</b>2
+<b>解释：</b>最长公共子路径为 [2,3] 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<b>输入：</b>n = 3, paths = [[0],[1],[2]]
+<b>输出：</b>0
+<b>解释：</b>三条路径没有公共子路径。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<b>输入：</b>n = 5, paths = [[<strong>0</strong>,1,2,3,4],
+                     [4,3,2,1,<strong>0</strong>]]
+<b>输出：</b>1
+<b>解释：</b>最长公共子路径为 [0]，[1]，[2]，[3] 和 [4] 。它们长度都为 1 。</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= n <= 10<sup>5</sup></code></li>
+	<li><code>m == paths.length</code></li>
+	<li><code>2 <= m <= 10<sup>5</sup></code></li>
+	<li><code>sum(paths[i].length) <= 10<sup>5</sup></code></li>
+	<li><code>0 <= paths[i][j] < n</code></li>
+	<li><code>paths[i]</code> 中同一个城市不会连续重复出现。</li>
+</ul>

data/3.算法高阶/1.leetcode/1925_迷宫中离入口最近的出口/desc.html

+<p>给你一个 <code>m x n</code> 的迷宫矩阵 <code>maze</code> （<strong>下标从 0 开始</strong>），矩阵中有空格子（用 <code>'.'</code> 表示）和墙（用 <code>'+'</code> 表示）。同时给你迷宫的入口 <code>entrance</code> ，用 <code>entrance = [entrance<sub>row</sub>, entrance<sub>col</sub>]</code> 表示你一开始所在格子的行和列。</p>
+
+<p>每一步操作，你可以往 <strong>上</strong>，<strong>下</strong>，<strong>左</strong> 或者 <strong>右</strong> 移动一个格子。你不能进入墙所在的格子，你也不能离开迷宫。你的目标是找到离 <code>entrance</code> <strong>最近</strong> 的出口。<strong>出口</strong> 的含义是 <code>maze</code> <strong>边界</strong> 上的 <strong>空格子</strong>。<code>entrance</code> 格子 <strong>不算</strong> 出口。</p>
+
+<p>请你返回从 <code>entrance</code> 到最近出口的最短路径的 <strong>步数</strong> ，如果不存在这样的路径，请你返回 <code>-1</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/nearest1-grid.jpg" style="width: 333px; height: 253px;">
+<pre><b>输入：</b>maze = [["+","+",".","+"],[".",".",".","+"],["+","+","+","."]], entrance = [1,2]
+<b>输出：</b>1
+<b>解释：</b>总共有 3 个出口，分别位于 (1,0)，(0,2) 和 (2,3) 。
+一开始，你在入口格子 (1,2) 处。
+- 你可以往左移动 2 步到达 (1,0) 。
+- 你可以往上移动 1 步到达 (0,2) 。
+从入口处没法到达 (2,3) 。
+所以，最近的出口是 (0,2) ，距离为 1 步。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/nearesr2-grid.jpg" style="width: 253px; height: 253px;">
+<pre><b>输入：</b>maze = [["+","+","+"],[".",".","."],["+","+","+"]], entrance = [1,0]
+<b>输出：</b>2
+<b>解释：</b>迷宫中只有 1 个出口，在 (1,2) 处。
+(1,0) 不算出口，因为它是入口格子。
+初始时，你在入口与格子 (1,0) 处。
+- 你可以往右移动 2 步到达 (1,2) 处。
+所以，最近的出口为 (1,2) ，距离为 2 步。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/nearest3-grid.jpg" style="width: 173px; height: 93px;">
+<pre><b>输入：</b>maze = [[".","+"]], entrance = [0,0]
+<b>输出：</b>-1
+<b>解释：</b>这个迷宫中没有出口。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>maze.length == m</code></li>
+	<li><code>maze[i].length == n</code></li>
+	<li><code>1 &lt;= m, n &lt;= 100</code></li>
+	<li><code>maze[i][j]</code> 要么是 <code>'.'</code> ，要么是 <code>'+'</code> 。</li>
+	<li><code>entrance.length == 2</code></li>
+	<li><code>0 &lt;= entrance<sub>row</sub> &lt; m</code></li>
+	<li><code>0 &lt;= entrance<sub>col</sub> &lt; n</code></li>
+	<li><code>entrance</code> 一定是空格子。</li>
+</ul>

data/3.算法高阶/1.leetcode/1927_规定时间内到达终点的最小花费/desc.html

+<p>一个国家有 <code>n</code> 个城市，城市编号为 <code>0</code> 到 <code>n - 1</code> ，题目保证 <strong>所有城市</strong> 都由双向道路 <b>连接在一起</b> 。道路由二维整数数组 <code>edges</code> 表示，其中 <code>edges[i] = [x<sub>i</sub>, y<sub>i</sub>, time<sub>i</sub>]</code> 表示城市 <code>x<sub>i</sub></code> 和 <code>y<sub>i</sub></code> 之间有一条双向道路，耗费时间为 <code>time<sub>i</sub></code> 分钟。两个城市之间可能会有多条耗费时间不同的道路，但是不会有道路两头连接着同一座城市。</p>
+
+<p>每次经过一个城市时，你需要付通行费。通行费用一个长度为 <code>n</code> 且下标从 <strong>0</strong> 开始的整数数组 <code>passingFees</code> 表示，其中 <code>passingFees[j]</code> 是你经过城市 <code>j</code> 需要支付的费用。</p>
+
+<p>一开始，你在城市 <code>0</code> ，你想要在 <code>maxTime</code> <strong>分钟以内</strong> （包含 <code>maxTime</code> 分钟）到达城市 <code>n - 1</code> 。旅行的 <strong>费用</strong> 为你经过的所有城市 <strong>通行费之和</strong> （<strong>包括</strong> 起点和终点城市的通行费）。</p>
+
+<p>给你 <code>maxTime</code>，<code>edges</code> 和 <code>passingFees</code> ，请你返回完成旅行的 <strong>最小费用</strong> ，如果无法在 <code>maxTime</code> 分钟以内完成旅行，请你返回 <code>-1</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<p><img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/leetgraph1-1.png" style="width: 371px; height: 171px;" /></p>
+
+<pre>
+<b>输入：</b>maxTime = 30, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]
+<b>输出：</b>11
+<b>解释：</b>最优路径为 0 -> 1 -> 2 -> 5 ，总共需要耗费 30 分钟，需要支付 11 的通行费。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/copy-of-leetgraph1-1.png" style="width: 371px; height: 171px;" /></strong></p>
+
+<pre>
+<b>输入：</b>maxTime = 29, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]
+<b>输出：</b>48
+<b>解释：</b>最优路径为 0 -> 3 -> 4 -> 5 ，总共需要耗费 26 分钟，需要支付 48 的通行费。
+你不能选择路径 0 -> 1 -> 2 -> 5 ，因为这条路径耗费的时间太长。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<b>输入：</b>maxTime = 25, edges = [[0,1,10],[1,2,10],[2,5,10],[0,3,1],[3,4,10],[4,5,15]], passingFees = [5,1,2,20,20,3]
+<b>输出：</b>-1
+<b>解释：</b>无法在 25 分钟以内从城市 0 到达城市 5 。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= maxTime <= 1000</code></li>
+	<li><code>n == passingFees.length</code></li>
+	<li><code>2 <= n <= 1000</code></li>
+	<li><code>n - 1 <= edges.length <= 1000</code></li>
+	<li><code>0 <= x<sub>i</sub>, y<sub>i</sub> <= n - 1</code></li>
+	<li><code>1 <= time<sub>i</sub> <= 1000</code></li>
+	<li><code>1 <= passingFees[j] <= 1000</code> </li>
+	<li>图中两个节点之间可能有多条路径。</li>
+	<li>图中不含有自环。</li>
+</ul>

data/3.算法高阶/1.leetcode/1928_数组串联/desc.html

+<p>给你一个长度为 <code>n</code> 的整数数组 <code>nums</code> 。请你构建一个长度为 <code>2n</code> 的答案数组 <code>ans</code> ，数组下标<strong> 从 0 开始计数 </strong>，对于所有 <code>0 <= i < n</code> 的 <code>i</code> ，满足下述所有要求：</p>
+
+<ul>
+	<li><code>ans[i] == nums[i]</code></li>
+	<li><code>ans[i + n] == nums[i]</code></li>
+</ul>
+
+<p>具体而言，<code>ans</code> 由两个 <code>nums</code> 数组 <strong>串联</strong> 形成。</p>
+
+<p>返回数组<em> </em><code>ans</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [1,2,1]
+<strong>输出：</strong>[1,2,1,1,2,1]
+<strong>解释：</strong>数组 ans 按下述方式形成：
+- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
+- ans = [1,2,1,1,2,1]</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [1,3,2,1]
+<strong>输出：</strong>[1,3,2,1,1,3,2,1]
+<strong>解释：</strong>数组 ans 按下述方式形成：
+- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
+- ans = [1,3,2,1,1,3,2,1]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == nums.length</code></li>
+	<li><code>1 <= n <= 1000</code></li>
+	<li><code>1 <= nums[i] <= 1000</code></li>
+</ul>

data/3.算法高阶/1.leetcode/1929_长度为 3 的不同回文子序列/desc.html

+<p>给你一个字符串 <code>s</code> ，返回 <code>s</code> 中 <strong>长度为 3 </strong>的<strong>不同回文子序列</strong> 的个数。</p>
+
+<p>即便存在多种方法来构建相同的子序列，但相同的子序列只计数一次。</p>
+
+<p><strong>回文</strong> 是正着读和反着读一样的字符串。</p>
+
+<p><strong>子序列</strong> 是由原字符串删除其中部分字符（也可以不删除）且不改变剩余字符之间相对顺序形成的一个新字符串。</p>
+
+<ul>
+	<li>例如，<code>"ace"</code> 是 <code>"<strong><em>a</em></strong>b<strong><em>c</em></strong>d<strong><em>e</em></strong>"</code> 的一个子序列。</li>
+</ul>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "aabca"
+<strong>输出：</strong>3
+<strong>解释：</strong>长度为 3 的 3 个回文子序列分别是：
+- "aba" ("<strong><em>a</em></strong>a<strong><em>b</em></strong>c<strong><em>a</em></strong>" 的子序列)
+- "aaa" ("<strong><em>aa</em></strong>bc<strong><em>a</em></strong>" 的子序列)
+- "aca" ("<strong><em>a</em></strong>ab<strong><em>ca</em></strong>" 的子序列)
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "adc"
+<strong>输出：</strong>0
+<strong>解释：</strong>"adc" 不存在长度为 3 的回文子序列。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>s = "bbcbaba"
+<strong>输出：</strong>4
+<strong>解释：</strong>长度为 3 的 4 个回文子序列分别是：
+- "bbb" ("<strong><em>bb</em></strong>c<strong><em>b</em></strong>aba" 的子序列)
+- "bcb" ("<strong><em>b</em></strong>b<strong><em>cb</em></strong>aba" 的子序列)
+- "bab" ("<strong><em>b</em></strong>bcb<strong><em>ab</em></strong>a" 的子序列)
+- "aba" ("bbcb<strong><em>aba</em></strong>" 的子序列)
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>3 <= s.length <= 10<sup>5</sup></code></li>
+	<li><code>s</code> 仅由小写英文字母组成</li>
+</ul>

data/3.算法高阶/1.leetcode/1931_合并多棵二叉搜索树/desc.html

+<p>给你 <code>n</code> 个 <strong>二叉搜索树的根节点</strong> ，存储在数组 <code>trees</code> 中（<strong>下标从 0 开始</strong>），对应 <code>n</code> 棵不同的二叉搜索树。<code>trees</code> 中的每棵二叉搜索树 <strong>最多有 3 个节点</strong> ，且不存在值相同的两个根节点。在一步操作中，将会完成下述步骤：</p>
+
+<ul>
+	<li>选择两个 <strong>不同的</strong> 下标 <code>i</code> 和 <code>j</code> ，要求满足在 <code>trees[i]</code> 中的某个 <strong>叶节点</strong> 的值等于 <code>trees[j]</code> 的 <strong>根节点的值</strong> 。</li>
+	<li>用 <code>trees[j]</code> 替换 <code>trees[i]</code> 中的那个叶节点。</li>
+	<li>从 <code>trees</code> 中移除 <code>trees[j]</code> 。</li>
+</ul>
+
+<p>如果在执行 <code>n - 1</code> 次操作后，能形成一棵有效的二叉搜索树，则返回结果二叉树的 <strong>根节点</strong> ；如果无法构造一棵有效的二叉搜索树<em>，</em>返回<em> </em><code>null</code> 。</p>
+
+<p>二叉搜索树是一种二叉树，且树中每个节点均满足下述属性：</p>
+
+<ul>
+	<li>任意节点的左子树中的值都 <strong>严格小于</strong> 此节点的值。</li>
+	<li>任意节点的右子树中的值都 <strong>严格大于</strong> 此节点的值。</li>
+</ul>
+
+<p>叶节点是不含子节点的节点。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d1.png" style="width: 450px; height: 163px;" />
+<pre>
+<strong>输入：</strong>trees = [[2,1],[3,2,5],[5,4]]
+<strong>输出：</strong>[3,2,5,1,null,4]
+<strong>解释：</strong>
+第一步操作中，选出 i=1 和 j=0 ，并将 trees[0] 合并到 trees[1] 中。
+删除 trees[0] ，trees = [[3,2,5,1],[5,4]] 。
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram.png" style="width: 450px; height: 181px;" />
+在第二步操作中，选出 i=0 和 j=1 ，将 trees[1] 合并到 trees[0] 中。
+删除 trees[1] ，trees = [[3,2,5,1,null,4]] 。
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram-2.png" style="width: 220px; height: 165px;" />
+结果树如上图所示，为一棵有效的二叉搜索树，所以返回该树的根节点。</pre>
+
+<p><strong>示例 2：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d2.png" style="width: 450px; height: 171px;" />
+<pre>
+<strong>输入：</strong>trees = [[5,3,8],[3,2,6]]
+<strong>输出：</strong>[]
+<strong>解释：</strong>
+选出 i=0 和 j=1 ，然后将 trees[1] 合并到 trees[0] 中。
+删除 trees[1] ，trees = [[5,3,8,2,6]] 。
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/24/diagram-3.png" style="width: 240px; height: 196px;" />
+结果树如上图所示。仅能执行一次有效的操作，但结果树不是一棵有效的二叉搜索树，所以返回 null 。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d3.png" style="width: 430px; height: 168px;" />
+<pre>
+<strong>输入：</strong>trees = [[5,4],[3]]
+<strong>输出：</strong>[]
+<strong>解释：</strong>无法执行任何操作。
+</pre>
+
+<p><strong>示例 4：</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/06/08/d4.png" style="width: 250px; height: 158px;" />
+<pre>
+<strong>输入：</strong>trees = [[2,1,3]]
+<strong>输出：</strong>[2,1,3]
+<strong>解释：</strong>trees 中只有一棵树，且这棵树已经是一棵有效的二叉搜索树，所以返回该树的根节点。
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>n == trees.length</code></li>
+	<li><code>1 <= n <= 5 * 10<sup>4</sup></code></li>
+	<li>每棵树中节点数目在范围 <code>[1, 3]</code> 内。</li>
+	<li>输入数据的每个节点可能有子节点但不存在子节点的子节点</li>
+	<li><code>trees</code> 中不存在两棵树根节点值相同的情况。</li>
+	<li>输入中的所有树都是 <strong>有效的二叉树搜索树</strong> 。</li>
+	<li><code>1 <= TreeNode.val <= 5 * 10<sup>4</sup></code>.</li>
+</ul>