Merge branch 'main' into main

Author: samarthswami1016

solution/0000-0099/0098.Validate Binary Search Tree/README.md

@@ -24,8 +24,8 @@ tags:
 <p><strong>有效</strong> 二叉搜索树定义如下：</p>
 
 <ul>
-	<li>节点的左<span data-keyword="subtree">子树</span>只包含<strong> 小于 </strong>当前节点的数。</li>
-	<li>节点的右子树只包含 <strong>大于</strong> 当前节点的数。</li>
+	<li>节点的左<span data-keyword="subtree">子树</span>只包含<strong>&nbsp;严格小于 </strong>当前节点的数。</li>
+	<li>节点的右子树只包含 <strong>严格大于</strong> 当前节点的数。</li>
 	<li>所有左子树和右子树自身必须也是二叉搜索树。</li>
 </ul>
 

solution/0000-0099/0098.Validate Binary Search Tree/README_EN.md

@@ -24,8 +24,8 @@ tags:
 <p>A <strong>valid BST</strong> is defined as follows:</p>
 
 <ul>
-	<li>The left <span data-keyword="subtree">subtree</span> of a node contains only nodes with keys <strong>less than</strong> the node&#39;s key.</li>
-	<li>The right subtree of a node contains only nodes with keys <strong>greater than</strong> the node&#39;s key.</li>
+	<li>The left <span data-keyword="subtree">subtree</span> of a node contains only nodes with keys&nbsp;<strong>strictly less than</strong> the node&#39;s key.</li>
+	<li>The right subtree of a node contains only nodes with keys <strong>strictly greater than</strong> the node&#39;s key.</li>
 	<li>Both the left and right subtrees must also be binary search trees.</li>
 </ul>
 

solution/0100-0199/0135.Candy/README.md

@@ -23,7 +23,7 @@ tags:
 
 <ul>
 	<li>每个孩子至少分配到 <code>1</code> 个糖果。</li>
-	<li>相邻两个孩子评分更高的孩子会获得更多的糖果。</li>
+	<li>相邻两个孩子中，评分更高的那个会获得更多的糖果。</li>
 </ul>
 
 <p>请你给每个孩子分发糖果，计算并返回需要准备的 <strong>最少糖果数目</strong> 。</p>

solution/0400-0499/0427.Construct Quad Tree/README.md

@@ -50,7 +50,7 @@ class Node {
 
 <p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0400-0499/0427.Construct%20Quad%20Tree/images/new_top.png" style="height: 181px; width: 777px;" /></p>
 
-<p>如果你想了解更多关于四叉树的内容，可以参考 <a href="https://en.wikipedia.org/wiki/Quadtree">wiki</a> 。</p>
+<p>如果你想了解更多关于四叉树的内容，可以参考 <a href="https://baike.baidu.com/item/%E5%9B%9B%E5%8F%89%E6%A0%91">百科</a> 。</p>
 
 <p><strong>四叉树格式：</strong></p>
 

solution/0400-0499/0472.Concatenated Words/README.md

@@ -8,6 +8,7 @@ tags:
     - 数组
     - 字符串
     - 动态规划
+    - 排序
 ---
 
 <!-- problem:start -->

solution/0400-0499/0472.Concatenated Words/README_EN.md

@@ -8,6 +8,7 @@ tags:
     - Array
     - String
     - Dynamic Programming
+    - Sorting
 ---
 
 <!-- problem:start -->

solution/0400-0499/0499.The Maze III/README_EN.md

@@ -23,7 +23,7 @@ tags:
 
 <!-- description:start -->
 
-<p>There is a ball in a <code>maze</code> with empty spaces (represented as <code>0</code>) and walls (represented as <code>1</code>). The ball can go through the empty spaces by rolling <strong>up, down, left or right</strong>, but it won&#39;t stop rolling until hitting a wall. When the ball stops, it could choose the next direction. There is also a hole in this maze. The ball will drop into the hole if it rolls onto the hole.</p>
+<p>There is a ball in a <code>maze</code> with empty spaces (represented as <code>0</code>) and walls (represented as <code>1</code>). The ball can go through the empty spaces by rolling <strong>up, down, left or right</strong>, but it won&#39;t stop rolling until hitting a wall. When the ball stops, it could choose the next direction (must be different from last chosen direction). There is also a hole in this maze. The ball will drop into the hole if it rolls onto the hole.</p>
 
 <p>Given the <code>m x n</code> <code>maze</code>, the ball&#39;s position <code>ball</code> and the hole&#39;s position <code>hole</code>, where <code>ball = [ball<sub>row</sub>, ball<sub>col</sub>]</code> and <code>hole = [hole<sub>row</sub>, hole<sub>col</sub>]</code>, return <em>a string </em><code>instructions</code><em> of all the instructions that the ball should follow to drop in the hole with the <strong>shortest distance</strong> possible</em>. If there are multiple valid instructions, return the <strong>lexicographically minimum</strong> one. If the ball can&#39;t drop in the hole, return <code>&quot;impossible&quot;</code>.</p>
 

solution/0800-0899/0853.Car Fleet/README_EN.md

@@ -21,7 +21,7 @@ tags:
 
 <p>There are <code>n</code> cars at given miles away from the starting mile 0, traveling to reach the mile <code>target</code>.</p>
 
-<p>You are given two integer array <code>position</code> and <code>speed</code>, both of length <code>n</code>, where <code>position[i]</code> is the starting mile of the <code>i<sup>th</sup></code> car and <code>speed[i]</code> is the speed of the <code>i<sup>th</sup></code> car in miles per hour.</p>
+<p>You are given two integer arrays&nbsp;<code>position</code> and <code>speed</code>, both of length <code>n</code>, where <code>position[i]</code> is the starting mile of the <code>i<sup>th</sup></code> car and <code>speed[i]</code> is the speed of the <code>i<sup>th</sup></code> car in miles per hour.</p>
 
 <p>A car cannot pass another car, but it can catch up and then travel next to it at the speed of the slower car.</p>
 

solution/0900-0999/0904.Fruit Into Baskets/README.md

@@ -83,9 +83,9 @@ tags:
 
 ### 方法一：哈希表 + 滑动窗口
 
-我们用哈希表 $cnt$ 维护当前窗口内的水果种类以及对应的数量，用双指针 $j$ 和 $i$ 维护窗口的左右边界。
+我们用哈希表 $\textit{cnt}$ 维护当前窗口内的水果种类以及对应的数量，用双指针 $j$ 和 $i$ 维护窗口的左右边界。
 
-遍历数组 `fruits`，将当前水果 $x$ 加入窗口，即 $cnt[x]++$，然后判断当前窗口内的水果种类是否超过了 $2$ 种，如果超过了 $2$ 种，就需要将窗口的左边界 $j$ 右移，直到窗口内的水果种类不超过 $2$ 种为止。然后更新答案，即 $ans = \max(ans, i - j + 1)$。
+遍历数组 $\textit{fruits}$，将当前水果 $x$ 加入窗口，即 $\textit{cnt}[x]++$，然后判断当前窗口内的水果种类是否超过了 $2$ 种，如果超过了 $2$ 种，就需要将窗口的左边界 $j$ 右移，直到窗口内的水果种类不超过 $2$ 种为止。然后更新答案，即 $\textit{ans} = \max(\textit{ans}, i - j + 1)$。
 
 遍历结束后，即可得到最终的答案。
 
@@ -105,7 +105,7 @@ j   i
   j     i
 ```
 
-时间复杂度 $O(n)$，其中 $n$ 为数组 `fruits` 的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $\textit{fruits}$ 的长度。空间复杂度 $O(1)$，因为哈希表 $\textit{cnt}$ 中的键值对数量最多为 $2$。
 
 <!-- tabs:start -->
 
@@ -248,19 +248,49 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int TotalFruit(int[] fruits) {
+        var cnt = new Dictionary<int, int>();
+        int ans = 0;
+        for (int i = 0, j = 0; i < fruits.Length; ++i) {
+            int x = fruits[i];
+            if (cnt.ContainsKey(x)) {
+                cnt[x]++;
+            } else {
+                cnt[x] = 1;
+            }
+            while (cnt.Count > 2) {
+                int y = fruits[j++];
+                if (cnt.ContainsKey(y)) {
+                    cnt[y]--;
+                    if (cnt[y] == 0) {
+                        cnt.Remove(y);
+                    }
+                }
+            }
+            ans = Math.Max(ans, i - j + 1);
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
 
 <!-- solution:start -->
 
-### 方法二：滑动窗口优化
+### 方法二：单调变长滑动窗口
 
 在方法一中，我们发现，窗口大小会时而变大，时而变小，这就需要我们每一次更新答案。
 
 但本题实际上求的是水果的最大数目，也就是“最大”的窗口，我们没有必要缩小窗口，只需要让窗口单调增大。于是代码就少了每次更新答案的操作，只需要在遍历结束后将此时的窗口大小作为答案返回即可。
 
-时间复杂度 $O(n)$，其中 $n$ 为数组 `fruits` 的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{fruits}$ 的长度。
 
 <!-- tabs:start -->
 
@@ -395,6 +425,35 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int TotalFruit(int[] fruits) {
+        var cnt = new Dictionary<int, int>();
+        int j = 0, n = fruits.Length;
+        foreach (int x in fruits) {
+            if (cnt.ContainsKey(x)) {
+                cnt[x]++;
+            } else {
+                cnt[x] = 1;
+            }
+
+            if (cnt.Count > 2) {
+                int y = fruits[j++];
+                if (cnt.ContainsKey(y)) {
+                    cnt[y]--;
+                    if (cnt[y] == 0) {
+                        cnt.Remove(y);
+                    }
+                }
+            }
+        }
+        return n - j;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0900-0999/0904.Fruit Into Baskets/README_EN.md

@@ -75,7 +75,7 @@ If we had started at the first tree, we would only pick from trees [1,2].
 
 We use a hash table $cnt$ to maintain the types and corresponding quantities of fruits in the current window, and use two pointers $j$ and $i$ to maintain the left and right boundaries of the window.
 
-We traverse the `fruits` array, add the current fruit $x$ to the window, i.e., $cnt[x]++$, then judge whether the types of fruits in the current window exceed $2$. If it exceeds $2$, we need to move the left boundary $j$ of the window to the right until the types of fruits in the window do not exceed $2$. Then we update the answer, i.e., $ans = \max(ans, i - j + 1)$.
+We traverse the $\textit{fruits}$ array, add the current fruit $x$ to the window, i.e., $cnt[x]++$, then judge whether the types of fruits in the current window exceed $2$. If it exceeds $2$, we need to move the left boundary $j$ of the window to the right until the types of fruits in the window do not exceed $2$. Then we update the answer, i.e., $ans = \max(ans, i - j + 1)$.
 
 After the traversal ends, we can get the final answer.
 
@@ -95,7 +95,7 @@ j   i
   j     i
 ```
 
-The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the `fruits` array.
+The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the $\textit{fruits}$ array.
 
 <!-- tabs:start -->
 
@@ -238,19 +238,49 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int TotalFruit(int[] fruits) {
+        var cnt = new Dictionary<int, int>();
+        int ans = 0;
+        for (int i = 0, j = 0; i < fruits.Length; ++i) {
+            int x = fruits[i];
+            if (cnt.ContainsKey(x)) {
+                cnt[x]++;
+            } else {
+                cnt[x] = 1;
+            }
+            while (cnt.Count > 2) {
+                int y = fruits[j++];
+                if (cnt.ContainsKey(y)) {
+                    cnt[y]--;
+                    if (cnt[y] == 0) {
+                        cnt.Remove(y);
+                    }
+                }
+            }
+            ans = Math.Max(ans, i - j + 1);
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
 
 <!-- solution:start -->
 
-### Solution 2: Sliding Window Optimization
+### Solution 2: Monotonic Variable-Length Sliding Window
 
 In Solution 1, we find that the window size sometimes increases and sometimes decreases, which requires us to update the answer each time.
 
 But what this problem actually asks for is the maximum number of fruits, that is, the "largest" window. We don't need to shrink the window, we just need to let the window monotonically increase. So the code omits the operation of updating the answer each time, and only needs to return the size of the window as the answer after the traversal ends.
 
-The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the `fruits` array.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the $\textit{fruits}$ array.
 
 <!-- tabs:start -->
 
@@ -385,6 +415,35 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int TotalFruit(int[] fruits) {
+        var cnt = new Dictionary<int, int>();
+        int j = 0, n = fruits.Length;
+        foreach (int x in fruits) {
+            if (cnt.ContainsKey(x)) {
+                cnt[x]++;
+            } else {
+                cnt[x] = 1;
+            }
+
+            if (cnt.Count > 2) {
+                int y = fruits[j++];
+                if (cnt.ContainsKey(y)) {
+                    cnt[y]--;
+                    if (cnt[y] == 0) {
+                        cnt.Remove(y);
+                    }
+                }
+            }
+        }
+        return n - j;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->