solve leetcode |830|[Positions of Large Groups]

Author: pymongo

README.md

@@ -0,0 +1,49 @@
+/**
+《数字信号处理》—— 镜像反射法生成格雷码:
+0 1 2
+0 0 00
+  1 01
+    11
+    10
+
+先将上次迭代的结果「上下镜像复制」一份，原顺序部分在左侧加上0，镜像对称部分在左侧加上1
+这样能保证格雷码的要求: 从上到下仅有1bit的变化
+如果懂了这些背景知识，那么这题就是easy难度了，首先左侧补0的那一半可以不做(二进制左侧加0等于不变)，因为原数组各项+0后还是原数组
+
+```python
+def gray_code(n: int) -> List[int]:
+    # 镜像反射法生成格雷码的技巧，左侧要补1的镜像部分的个数刚好等于head，而且
+    res, head = [0], 1
+    for _ in range(n):
+        for i in range(head - 1, -1, -1):
+            res.append(head + res[i])
+        head *= 2
+    return res
+```
+*/
+fn gray_code(n: i32) -> Vec<i32> {
+    let mut res: Vec<i32> = Vec::with_capacity(2usize.pow(n as u32));
+    res.push(0);
+    // head表示镜像反射法生成格雷码中左侧补1需要加上的数，刚好等于镜像后的下半部分(需要左边加一个1)的个数
+    let mut head: i32 = 1;
+    for _ in 0..n {
+        // 镜像对称部分在左侧加上1
+        for i in (0..head as usize).rev() {
+            res.push(head + res[i]);
+        }
+        head <<= 1;
+    }
+    res
+    /* 位运算的解法?
+    let mut res=vec![];
+    for i in 0..1<<n{
+        res.push(i^i>>1);
+    }
+    res
+    */
+}
+
+#[test]
+fn test_gray_code() {
+    assert_eq!(gray_code(2), vec![0b00, 0b01, 0b11, 0b10]);
+}

src/bitwise/gray_code.rs

@@ -1,16 +1,6 @@
 mod count_ones;
 mod find_single_number;
+mod gray_code;
 mod is_power_of_2;
 mod nim_game;
-
-/// https://leetcode.com/problems/reverse-bits/
-fn reverse_bits(mut n: u32) -> u32 {
-    let (mut ret, mut power) = (0u32, 0u32);
-    while n != 0 {
-        ret += (n & 1) << power;
-        n >>= 1;
-        power -= 1;
-    }
-    ret
-    // n.reverse_bits()
-}
+mod reverse_bits;

src/bitwise/mod.rs

@@ -0,0 +1,11 @@
+/// https://leetcode.com/problems/reverse-bits/
+fn reverse_bits(mut n: u32) -> u32 {
+    let (mut ret, mut power) = (0u32, 0u32);
+    while n != 0 {
+        ret += (n & 1) << power;
+        n >>= 1;
+        power -= 1;
+    }
+    ret
+    // n.reverse_bits()
+}

src/bitwise/reverse_bits.rs

@@ -0,0 +1,41 @@
+/// ## 两个字符串之间的最长公共子串
+/// 本算法不是leetcode的题，只是leetcode第五题的最长公共子串的解法的引申出「如何寻找两个字符串的最长公共部分」d的问题
+/// DP思路：如果s1[x]==s2[y]且s1[x-1]==s2[y-1]，说明当前子串是公共子串
+fn longest_common_substr_dp(s1: String, s2: String) -> String {
+    let (s1, s2) = (s1.into_bytes(), s2.into_bytes());
+    let (str1_len, str2_len) = (s1.len(), s2.len());
+    let mut max_len: usize = 0;
+    let mut max_end_index: usize = 0;
+    let mut dp: Vec<Vec<usize>> = vec![vec![0; str1_len]; str2_len];
+    for x in 0..str1_len {
+        for y in 0..str2_len {
+            if s1[x] == s2[y] {
+                if x == 0 || y == 0 {
+                    dp[x][y] = 1;
+                } else {
+                    // 遍历第N行时只需用到N-1行的数据
+                    // 所以用两个1*N的数组即可，将空间复杂度从O(n^2)降低到O(2n)
+                    dp[x][y] = dp[x - 1][y - 1] + 1;
+                }
+                if dp[x][y] > max_len {
+                    max_len = dp[x][y];
+                    max_end_index = x;
+                }
+            }
+        }
+    }
+    unsafe {
+        String::from_utf8_unchecked(s1[(max_end_index - max_len + 1)..=max_end_index].to_vec())
+    }
+}
+
+#[test]
+fn test_longest_common_substr_dp() {
+    const TEST_CASES: [(&str, &str, &str); 1] = [("caba", "abac", "aba")];
+    for &(input1, input2, expected) in TEST_CASES.iter() {
+        assert_eq!(
+            longest_common_substr_dp(input1.to_string(), input2.to_string()),
+            expected
+        );
+    }
+}

src/easy/coin_lcci.rs src/dp/dp_easy.rs

@@ -1,5 +1,7 @@
+mod dp_easy;
 mod drop_eggs;
 mod freedom_trail;
 mod jump_game_2;
+mod longest_common_substr;
 mod longest_palindromic_substr;
 mod trapping_rain_water;

src/dp/longest_common_substr.rs

@@ -0,0 +1,75 @@
+/** https://leetcode.com/problems/unique-paths/
+这题虽然以我今天的水平来看非常简单，但是由于除了DP外还有组合数解法而且还是经典题，值得单独归档成一个文件而非纳入dp_easy中
+
+## DP解法
+本题类似70题(爬楼梯)，爬到第N格梯子的路径=f(n-1)+f(n-2)
+由于从左下角(0,0)走到右上角(m,n)的最短路径只能往上或往右走
+所以得到递推式(状态转移方程):
+f(m,n)=f(m-1,n)+f(m,n-1)
+
+### DP遍历方向
+初始条件：第一列和最底下的一行全为1
+遍历方向：从底下往上数第二行的第2个元素开始往右扫，每行是从左往右，整体是从下往上
+
+## 组合数解法
+从(0,0)走到(m,n)总共需要走m+n步，
+要在m+n中选m次往右走，或者选n次往左走
+极致地简化了问题，将问题抽象成组合数问题
+组合问题(要从班上m+n个同学中选m个做值日，或者选n个不做值日)
+知识补充：排列问题(从班上m+n个同学中列出田径100米赛跑前3名的可能情况)
+
+> return math.comb(m-1 + n-1, n-1) if m > n else math.comb(n-1 + m-1, m-1)
+
+```go
+func UniquePaths(m int, n int) int {
+	// 端点是4x4，但是棋盘的格子就3x3
+	max, min := m-1, n-1
+	if min > max {
+		max, min = min, max
+	}
+	result := 1
+	sum := max+min
+	for i:=0; i<min; i++ {
+		result *= sum-i
+		// 先乘后除，避免result溢出
+		result /= i+1
+	}
+	return result
+}
+```
+
+### 组合数解法int溢出问题
+在Go语言中，遍历计算组合数时先乘后除不会溢出，而在Rust中即便用了u32类型也会在(52,9)这个测试用例上溢出
+我在本题采用了u64类型，也算避免了溢出
+关于能否整除的问题，我试了下，如果分子的阶乘是从大到小，分母的阶乘是从小到大，大概率不会溢出
+
+### 端点与格子的问题
+由于输入的m、n表示的是端点数(联想围棋的点)
+但是走路的方式却是在网格上走，所以实际的m和n应该是m-1和n-1
+
+## 参看
+[走格子/棋盘问题 有多少条路径可走](https://blog.csdn.net/yusiguyuan/article/details/12875415)
+*/
+fn unique_paths(m: i32, n: i32) -> i32 {
+    let m: u64 = (m - 1) as u64;
+    let mut n: u64 = (n - 1) as u64;
+    let mut res: u64 = 1;
+    let sum: u64 = m + n;
+    if n > m {
+        n = m;
+    }
+    // Example: 组合数C(5,2)=5*4/1*2
+    for i in 0..n {
+        res *= sum - i;
+        res /= i + 1;
+    }
+    res as i32
+}
+
+#[test]
+fn test_unique_paths() {
+    const TEST_CASES: [(i32, i32, i32); 2] = [(23, 12, 193536720), (51, 9, 1916797311)];
+    for &(m, n, expected) in TEST_CASES.iter() {
+        assert_eq!(unique_paths(m, n), expected);
+    }
+}

src/dp/mod.rs

@@ -1,19 +1,15 @@
-struct Solution;
-
-impl Solution {
-    fn find_numbers(nums: Vec<i32>) -> i32 {
-        let mut res = 0;
-        for num in nums {
-            let mut n = num;
-            let mut digit_count = 0;
-            while n != 0 {
-                n /= 10;
-                digit_count += 1;
-            }
-            if digit_count % 2 == 0 {
-                res += 1;
-            }
+fn find_numbers(nums: Vec<i32>) -> i32 {
+    let mut res = 0;
+    for num in nums {
+        let mut n = num;
+        let mut digit_count = 0;
+        while n != 0 {
+            n /= 10;
+            digit_count += 1;
+        }
+        if digit_count % 2 == 0 {
+            res += 1;
         }
-        res
     }
+    res
 }

src/dp/unique_paths.rs

@@ -1,6 +1,5 @@
 mod count_good_triplets;
 mod find_numbers_with_even_number_of_digits;
-mod gray_code;
 mod partition_array;
 mod queries_on_a_permutation_with_key;
 mod squares_of_a_sorted_array;

src/easy/array/find_numbers_with_even_number_of_digits.rs

@@ -0,0 +1,31 @@
+/// '#'表示退格操作，请你比较两个含退格操作符的字符串是否相等
+fn backspace_compare(s: String, t: String) -> bool {
+    fn parse(s: String) -> Vec<u8> {
+        let mut ret: Vec<u8> = Vec::new();
+        for byte in s.into_bytes() {
+            if byte == b'#' {
+                let _ = ret.pop();
+            } else {
+                ret.push(byte);
+            }
+        }
+        ret
+    }
+    parse(s) == parse(t)
+}
+
+#[test]
+fn test_backspace_compare() {
+    const TEST_CASES: [(&str, &str, bool); 4] = [
+        ("ab#c", "ad#c", true),
+        ("ab##", "c#d#", true),
+        ("a##c", "#a#c", true),
+        ("a#c", "b", false),
+    ];
+    for &(s, t, expected) in &TEST_CASES {
+        assert_eq!(
+            Solution::backspace_compare(s.to_string(), t.to_string()),
+            expected
+        );
+    }
+}

src/easy/array/gray_code.rs

@@ -5,7 +5,7 @@ count if nums[i] == nums[j] and i < j
 思路: collection.Counter统计输入数组每个数字的出现次数，例如3出现了3次，那么就有math.comb(3,2)=3*2=6对满足i<j且nums[i]==nums[j]
 
 除了Counter，还有已知输入全小写字母字符串需要一些记忆操作例如最长无重复子串，也建议用固定长数组，下标寻址比HashMap快
-> return sum(map(lambda v: math.comb(v, 2), collections.Counter(nums).values()))
+> return sum(map(lambda v: math_or_puzzle_game.comb(v, 2), collections.Counter(nums).values()))
 */
 fn num_identical_pairs(nums: Vec<i32>) -> i32 {
     let mut counter = [0u8; 101];
@@ -243,7 +243,7 @@ fn count_pairs_permutation_solution(nums: Vec<i32>) -> i32 {
         for j in i..n {
             if is_power_of_2(unique[i] + unique[j]) {
                 if i == j {
-                    // math.comb(count, 2)
+                    // math_or_puzzle_game.comb(count, 2)
                     ret += (counter[i] - 1) * counter[i] / 2;
                 } else {
                     ret += counter[i] * counter[j];
@@ -282,7 +282,7 @@ fn test_gen_twos_geometric_series() {
     println!("{:?}", gen_twos_geometric_series::<22>());
 }
 
-/// 这个解法也就是把时间复杂度从O(n^2)降低到O(22n
+/// 这个解法也就是把时间复杂度从O(n^2)降低到O(22n）
 fn count_pairs_two_sum_solution(nums: Vec<i32>) -> i32 {
     // 照顾下leetcode.com的const fn不支持while loop
     // const TWO_SUMS: [i32; 22] = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152];