[pull] master from youngyangyang04:master

problems/0392.判断子序列.md

@@ -259,9 +259,49 @@ func isSubsequence(s string, t string) bool {
 }
 ```
 
+Rust：
+
+```rust
+impl Solution {
+    pub fn is_subsequence(s: String, t: String) -> bool {
+        let mut dp = vec![vec![0; t.len() + 1]; s.len() + 1];
+        for (i, char_s) in s.chars().enumerate() {
+            for (j, char_t) in t.chars().enumerate() {
+                if char_s == char_t {
+                    dp[i + 1][j + 1] = dp[i][j] + 1;
+                    continue;
+                }
+                dp[i + 1][j + 1] = dp[i + 1][j]
+            }
+        }
+        dp[s.len()][t.len()] == s.len()
+    }
+}
+```
 
-
-
+> 滚动数组
+
+```rust
+impl Solution {
+    pub fn is_subsequence(s: String, t: String) -> bool {
+        let mut dp = vec![0; t.len() + 1];
+        let (s, t) = (s.as_bytes(), t.as_bytes());
+        for &byte_s in s {
+            let mut pre = 0;
+            for j in 0..t.len() {
+                let temp = dp[j + 1];
+                if byte_s == t[j] {
+                    dp[j + 1] = pre + 1;
+                } else {
+                    dp[j + 1] = dp[j];
+                }
+                pre = temp;
+            }
+        }
+        dp[t.len()] == s.len()
+    }
+}
+```
 
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">

problems/1035.不相交的线.md

@@ -155,21 +155,44 @@ func max(a, b int) int {
 ### Rust:
 
 ```rust
-pub fn max_uncrossed_lines(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
-    let (n, m) = (nums1.len(), nums2.len());
-    let mut last = vec![0; m + 1]; // 记录滚动数组
-    let mut dp = vec![0; m + 1];
-    for i in 1..=n {
-        dp.swap_with_slice(&mut last);
-        for j in 1..=m {
-            if nums1[i - 1] == nums2[j - 1] {
-                dp[j] = last[j - 1] + 1;
-            } else {
-                dp[j] = last[j].max(dp[j - 1]);
+impl Solution {
+    pub fn max_uncrossed_lines(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
+        let mut dp = vec![vec![0; nums2.len() + 1]; nums1.len() + 1];
+        for (i, num1) in nums1.iter().enumerate() {
+            for (j, num2) in nums2.iter().enumerate() {
+                if num1 == num2 {
+                    dp[i + 1][j + 1] = dp[i][j] + 1;
+                } else {
+                    dp[i + 1][j + 1] = dp[i][j + 1].max(dp[i + 1][j]);
+                }
+            }
+        }
+        dp[nums1.len()][nums2.len()]
+    }
+}
+```
+
+> 滚动数组
+
+```rust
+impl Solution {
+    pub fn max_uncrossed_lines(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
+        let mut dp = vec![0; nums2.len() + 1];
+        for num1 in nums1 {
+            let mut prev = 0;
+            for (j, &num2) in nums2.iter().enumerate() {
+                let temp = dp[j + 1];
+                if num1 == num2 {
+                    // 使用上一次的状态，防止重复计算
+                    dp[j + 1] = prev + 1;
+                } else {
+                    dp[j + 1] = dp[j + 1].max(dp[j]);
+                }
+                prev = temp;
             }
         }
+        dp[nums2.len()]
     }
-    dp[m]
 }
 ```
 

problems/1143.最长公共子序列.md

@@ -329,25 +329,50 @@ function longestCommonSubsequence(text1: string, text2: string): number {
 };
 ```
 
-### Rust:
+### Rust
 
 ```rust
-pub fn longest_common_subsequence(text1: String, text2: String) -> i32 {
-    let (n, m) = (text1.len(), text2.len());
-    let (s1, s2) = (text1.as_bytes(), text2.as_bytes());
-    let mut dp = vec![0; m + 1];
-    let mut last = vec![0; m + 1];
-    for i in 1..=n {
-        dp.swap_with_slice(&mut last);
-        for j in 1..=m {
-            dp[j] = if s1[i - 1] == s2[j - 1] {
-                last[j - 1] + 1
-            } else {
-                last[j].max(dp[j - 1])
-            };
+impl Solution {
+    pub fn longest_common_subsequence(text1: String, text2: String) -> i32 {
+        let mut dp = vec![vec![0; text2.len() + 1]; text1.len() + 1];
+        for (i, c1) in text1.chars().enumerate() {
+            for (j, c2) in text2.chars().enumerate() {
+                if c1 == c2 {
+                    dp[i + 1][j + 1] = dp[i][j] + 1;
+                } else {
+                    dp[i + 1][j + 1] = dp[i][j + 1].max(dp[i + 1][j]);
+                }
+            }
+        }
+        dp[text1.len()][text2.len()]
+    }
+}
+```
+
+一维：
+
+```rust
+impl Solution {
+    pub fn longest_common_subsequence(text1: String, text2: String) -> i32 {
+        let mut dp = vec![0; text2.len() + 1];
+        for c1 in text1.chars() {
+            // 初始化 prev
+            let mut prev = 0;
+
+            for (j, c2) in text2.chars().enumerate() {
+                let temp = dp[j + 1];
+                if c1 == c2 {
+                    // 使用上一次的状态，防止重复计算
+                    dp[j + 1] = prev + 1;
+                } else {
+                    dp[j + 1] = dp[j + 1].max(dp[j]);
+                }
+                // 使用上一次的状态更新 prev
+                prev = temp;
+            }
         }
+        dp[text2.len()]
     }
-    dp[m]
 }
 ```
 

problems/1207.独一无二的出现次数.md

@@ -200,10 +200,30 @@ function uniqueOccurrences(arr: number[]): boolean {
     })
     return countMap.size === new Set(countMap.values()).size;
 };
+``` 
+
+
+### Go：
+```Go
+func uniqueOccurrences(arr []int) bool {
+	count := make(map[int]int) // 统计数字出现的频率
+	for _, v := range arr {
+		count[v] += 1
+	}
+	fre := make(map[int]struct{}) // 看相同频率是否重复出现
+	for _, v := range count {
+		if _, ok := fre[v]; ok {
+			return false
+		}
+		fre[v] = struct{}{}
+	}
+	return true
+}
 ```
 
 
 
+
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>