Merge branch 'doocs:main' into main

Author: Nothing-avil

images/starcharts.svg

@@ -357,7 +357,7 @@ class Solution {
         var tail: TreeNode? = nil
         var stack = [TreeNode]()
         var cur = root
-        
+
         while !stack.isEmpty || cur != nil {
             while cur != nil {
                 stack.append(cur!)

lcof2/剑指 Offer II 052. 展平二叉搜索树/README.md

@@ -56,8 +56,7 @@ tags:
 <p><strong>进阶：</strong></p>
 
 <ul>
-	<li>这是 <a href="https://leetcode.cn/problems/search-in-rotated-sorted-array/description/">搜索旋转排序数组</a>&nbsp;的延伸题目，本题中的&nbsp;<code>nums</code>&nbsp; 可能包含重复元素。</li>
-	<li>这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？</li>
+	<li>此题与&nbsp;<a href="https://leetcode.cn/problems/search-in-rotated-sorted-array/description/">搜索旋转排序数组</a>&nbsp;相似，但本题中的&nbsp;<code>nums</code>&nbsp; 可能包含 <strong>重复</strong> 元素。这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？</li>
 </ul>
 
 <p>&nbsp;</p>

solution/0000-0099/0081.Search in Rotated Sorted Array II/README.md

@@ -18,25 +18,50 @@ tags:
 
 <!-- description:start -->
 
-<p>给定一个字符串，对该字符串可以进行 &ldquo;移位&rdquo; 的操作，也就是将字符串中每个字母都变为其在字母表中后续的字母，比如：<code>&quot;abc&quot; -&gt; &quot;bcd&quot;</code>。这样，我们可以持续进行 &ldquo;移位&rdquo; 操作，从而生成如下移位序列：</p>
+<p>对字符串进行 “移位” 的操作：</p>
 
-<pre>&quot;abc&quot; -&gt; &quot;bcd&quot; -&gt; ... -&gt; &quot;xyz&quot;</pre>
+<ul>
+	<li><strong>右移</strong>：将字符串中每个字母都变为其在字母表中 <strong>后续</strong> 的字母，其中用 'a' 替换 'z'。比如，<code>"abc"</code>&nbsp;能够右移为&nbsp;<code>"bcd"</code>，<code>"xyz"</code>&nbsp;能够右移为&nbsp;<code>"yza"</code>。</li>
+	<li><strong>左移</strong>：将字符串中每个字母都变为其在字母表中 <b>之前</b>&nbsp;的字母，其中用 'z' 替换 'a'。比如，<code>"bcd"</code>&nbsp;能够右移为&nbsp;<code>"abc"</code>，<code>"yza"</code>&nbsp;能够右移为&nbsp;<code>"xyz"</code>。</li>
+</ul>
 
-<p>给定一个包含仅小写字母字符串的列表，将该列表中所有满足&nbsp;&ldquo;移位&rdquo; 操作规律的组合进行分组并返回。</p>
+<p>我们可以不断地向两个方向移动字符串，形成 <strong>无限的移位序列</strong>。</p>
+
+<ul>
+	<li>例如，移动&nbsp;<code>"abc"</code>&nbsp;来形成序列：<code>... &lt;-&gt; "abc" &lt;-&gt; "bcd" &lt;-&gt; ... &lt;-&gt; "xyz" &lt;-&gt; "yza" &lt;-&gt; ... &lt;-&gt; "zab" &lt;-&gt; "abc" &lt;-&gt; ...</code></li>
+</ul>
+
+<p>给定一个字符串数组&nbsp;<code>strings</code>，将属于相同移位序列的所有&nbsp;<code>strings[i]</code>&nbsp;进行分组。你可以以 <strong>任意顺序</strong> 返回答案。</p>
+
+<p>&nbsp;</p>
+
+<p><strong class="example">示例 1：</strong></p>
+
+<div class="example-block">
+<p><strong>输入：</strong><span class="example-io">strings = ["abc","bcd","acef","xyz","az","ba","a","z"]</span></p>
+
+<p><strong>输出：</strong><span class="example-io">[["acef"],["a","z"],["abc","bcd","xyz"],["az","ba"]]</span></p>
 
 <p>&nbsp;</p>
+</div>
+
+<p><strong class="example">示例 2：</strong></p>
+
+<div class="example-block">
+<p><strong>输入：</strong><span class="example-io">strings = ["a"]</span></p>
+
+<p><strong>输出：</strong><span class="example-io">[["a"]]</span></p>
+
+<p>&nbsp;</p>
+</div>
+
+<p><strong>提示：</strong></p>
 
-<p><strong>示例：</strong></p>
-
-<pre><strong>输入：</strong><code>[&quot;abc&quot;, &quot;bcd&quot;, &quot;acef&quot;, &quot;xyz&quot;, &quot;az&quot;, &quot;ba&quot;, &quot;a&quot;, &quot;z&quot;]</code>
-<strong>输出：</strong>
-[
-  [&quot;abc&quot;,&quot;bcd&quot;,&quot;xyz&quot;],
-  [&quot;az&quot;,&quot;ba&quot;],
-  [&quot;acef&quot;],
-  [&quot;a&quot;,&quot;z&quot;]
-]
-<strong>解释：</strong>可以认为字母表首尾相接，所以 &#39;z&#39; 的后续为 &#39;a&#39;，所以 [&quot;az&quot;,&quot;ba&quot;] 也满足 &ldquo;移位&rdquo; 操作规律。</pre>
+<ul>
+	<li><code>1 &lt;= strings.length &lt;= 200</code></li>
+	<li><code>1 &lt;= strings[i].length &lt;= 50</code></li>
+	<li><code>strings[i]</code>&nbsp;只包含小写英文字母。</li>
+</ul>
 
 <!-- description:end -->
 

solution/0200-0299/0249.Group Shifted Strings/README.md

@@ -56,7 +56,23 @@ coins =  3*1*5    +   3*5*8   +  1*3*8  + 1*8*1 = 167</pre>
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：动态规划
+
+我们记数组 $nums$ 的长度为 $n$。根据题目描述，我们可以在数组 $nums$ 的左右两端各添加一个 $1$，记为 $arr$。
+
+然后，我们定义 $f[i][j]$ 表示戳破区间 $[i, j]$ 内的所有气球能得到的最多硬币数，那么答案即为 $f[0][n+1]$。
+
+对于 $f[i][j]$，我们枚举区间 $[i, j]$ 内的所有位置 $k$，假设 $k$ 是最后一个戳破的气球，那么我们可以得到如下状态转移方程：
+
+$$
+f[i][j] = \max(f[i][j], f[i][k] + f[k][j] + arr[i] \times arr[k] \times arr[j])
+$$
+
+在实现上，由于 $f[i][j]$ 的状态转移方程中涉及到 $f[i][k]$ 和 $f[k][j]$，其中 $i < k < j$，因此我们需要从大到小地遍历 $i$，从小到大地遍历 $j$，这样才能保证当计算 $f[i][j]$ 时 $f[i][k]$ 和 $f[k][j]$ 已经被计算出来。
+
+最后，我们返回 $f[0][n+1]$ 即可。
+
+时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为数组 $nums$ 的长度。
 
 <!-- tabs:start -->
 
@@ -65,40 +81,35 @@ coins =  3*1*5    +   3*5*8   +  1*3*8  + 1*8*1 = 167</pre>
 ```python
 class Solution:
     def maxCoins(self, nums: List[int]) -> int:
-        nums = [1] + nums + [1]
         n = len(nums)
-        dp = [[0] * n for _ in range(n)]
-        for l in range(2, n):
-            for i in range(n - l):
-                j = i + l
+        arr = [1] + nums + [1]
+        f = [[0] * (n + 2) for _ in range(n + 2)]
+        for i in range(n - 1, -1, -1):
+            for j in range(i + 2, n + 2):
                 for k in range(i + 1, j):
-                    dp[i][j] = max(
-                        dp[i][j], dp[i][k] + dp[k][j] + nums[i] * nums[k] * nums[j]
-                    )
-        return dp[0][-1]
+                    f[i][j] = max(f[i][j], f[i][k] + f[k][j] + arr[i] * arr[k] * arr[j])
+        return f[0][-1]
 ```
 
 #### Java
 
 ```java
 class Solution {
     public int maxCoins(int[] nums) {
-        int[] vals = new int[nums.length + 2];
-        vals[0] = 1;
-        vals[vals.length - 1] = 1;
-        System.arraycopy(nums, 0, vals, 1, nums.length);
-        int n = vals.length;
-        int[][] dp = new int[n][n];
-        for (int l = 2; l < n; ++l) {
-            for (int i = 0; i + l < n; ++i) {
-                int j = i + l;
-                for (int k = i + 1; k < j; ++k) {
-                    dp[i][j]
-                        = Math.max(dp[i][j], dp[i][k] + dp[k][j] + vals[i] * vals[k] * vals[j]);
+        int n = nums.length;
+        int[] arr = new int[n + 2];
+        arr[0] = 1;
+        arr[n + 1] = 1;
+        System.arraycopy(nums, 0, arr, 1, n);
+        int[][] f = new int[n + 2][n + 2];
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i + 2; j <= n + 1; j++) {
+                for (int k = i + 1; k < j; k++) {
+                    f[i][j] = Math.max(f[i][j], f[i][k] + f[k][j] + arr[i] * arr[k] * arr[j]);
                 }
             }
         }
-        return dp[0][n - 1];
+        return f[0][n + 1];
     }
 }
 ```
@@ -109,19 +120,21 @@ class Solution {
 class Solution {
 public:
     int maxCoins(vector<int>& nums) {
-        nums.insert(nums.begin(), 1);
-        nums.push_back(1);
         int n = nums.size();
-        vector<vector<int>> dp(n, vector<int>(n));
-        for (int l = 2; l < n; ++l) {
-            for (int i = 0; i + l < n; ++i) {
-                int j = i + l;
+        vector<int> arr(n + 2, 1);
+        for (int i = 0; i < n; ++i) {
+            arr[i + 1] = nums[i];
+        }
+
+        vector<vector<int>> f(n + 2, vector<int>(n + 2, 0));
+        for (int i = n - 1; i >= 0; --i) {
+            for (int j = i + 2; j <= n + 1; ++j) {
                 for (int k = i + 1; k < j; ++k) {
-                    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j] + nums[i] * nums[k] * nums[j]);
+                    f[i][j] = max(f[i][j], f[i][k] + f[k][j] + arr[i] * arr[k] * arr[j]);
                 }
             }
         }
-        return dp[0][n - 1];
+        return f[0][n + 1];
     }
 };
 ```
@@ -130,44 +143,72 @@ public:
 
 ```go
 func maxCoins(nums []int) int {
-	vals := make([]int, len(nums)+2)
-	for i := 0; i < len(nums); i++ {
-		vals[i+1] = nums[i]
-	}
-	n := len(vals)
-	vals[0], vals[n-1] = 1, 1
-	dp := make([][]int, n)
-	for i := 0; i < n; i++ {
-		dp[i] = make([]int, n)
-	}
-	for l := 2; l < n; l++ {
-		for i := 0; i+l < n; i++ {
-			j := i + l
-			for k := i + 1; k < j; k++ {
-				dp[i][j] = max(dp[i][j], dp[i][k]+dp[k][j]+vals[i]*vals[k]*vals[j])
-			}
-		}
-	}
-	return dp[0][n-1]
+    n := len(nums)
+    arr := make([]int, n+2)
+    arr[0] = 1
+    arr[n+1] = 1
+    copy(arr[1:], nums)
+
+    f := make([][]int, n+2)
+    for i := range f {
+        f[i] = make([]int, n+2)
+    }
+
+    for i := n - 1; i >= 0; i-- {
+        for j := i + 2; j <= n+1; j++ {
+            for k := i + 1; k < j; k++ {
+                f[i][j] = max(f[i][j], f[i][k] + f[k][j] + arr[i]*arr[k]*arr[j])
+            }
+        }
+    }
+
+    return f[0][n+1]
 }
 ```
 
 #### TypeScript
 
 ```ts
 function maxCoins(nums: number[]): number {
-    let n = nums.length;
-    let dp = Array.from({ length: n + 1 }, v => new Array(n + 2).fill(0));
-    nums.unshift(1);
-    nums.push(1);
-    for (let i = n - 1; i >= 0; --i) {
-        for (let j = i + 2; j < n + 2; ++j) {
-            for (let k = i + 1; k < j; ++k) {
-                dp[i][j] = Math.max(nums[i] * nums[k] * nums[j] + dp[i][k] + dp[k][j], dp[i][j]);
+    const n = nums.length;
+    const arr = Array(n + 2).fill(1);
+    for (let i = 0; i < n; i++) {
+        arr[i + 1] = nums[i];
+    }
+
+    const f: number[][] = Array.from({ length: n + 2 }, () => Array(n + 2).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = i + 2; j <= n + 1; j++) {
+            for (let k = i + 1; k < j; k++) {
+                f[i][j] = Math.max(f[i][j], f[i][k] + f[k][j] + arr[i] * arr[k] * arr[j]);
+            }
+        }
+    }
+    return f[0][n + 1];
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn max_coins(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut arr = vec![1; n + 2];
+        for i in 0..n {
+            arr[i + 1] = nums[i];
+        }
+
+        let mut f = vec![vec![0; n + 2]; n + 2];
+        for i in (0..n).rev() {
+            for j in i + 2..n + 2 {
+                for k in i + 1..j {
+                    f[i][j] = f[i][j].max(f[i][k] + f[k][j] + arr[i] * arr[k] * arr[j]);
+                }
             }
         }
+        f[0][n + 1]
     }
-    return dp[0][n + 1];
 }
 ```