feat: add solutions to lc problems

- No.0074.Search a 2D Matrix
- No.0078.Subsets
- No.0090.Subsets II
- No.1351.Count Negative Numbers in a Sorted Matrix

Author: YangFong

solution/0000-0099/0074.Search a 2D Matrix/README.md

@@ -48,19 +48,19 @@
 
 将二维矩阵逻辑展开，然后二分查找即可。
 
-时间复杂度 O(logmn)。
+时间复杂度：$O(logmn)$。
 
 **方法二：从左下角或右上角搜索**
 
-这里我们以左下角作为起始搜索点，往右上方向开始搜索，比较当前元素 `matrix[i][j]`与 target 的大小关系：
+这里我们以左下角作为起始搜索点，往右上方向开始搜索，比较当前元素 `matrix[i][j]` 与 `target` 的大小关系：
 
 -   若 `matrix[i][j] == target`，说明找到了目标值，直接返回 true。
 -   若 `matrix[i][j] > target`，说明这一行从当前位置开始往右的所有元素均大于 target，应该让 i 指针往上移动，即 `i--`。
 -   若 `matrix[i][j] < target`，说明这一列从当前位置开始往上的所有元素均小于 target，应该让 j 指针往右移动，即 `j++`。
 
 若搜索结束依然找不到 target，返回 false。
 
-时间复杂度 O(m + n)。
+时间复杂度：$O(m + n)$。
 
 <!-- tabs:start -->
 
@@ -284,6 +284,32 @@ func searchMatrix(matrix [][]int, target int) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function searchMatrix(matrix: number[][], target: number): boolean {
+    const m = matrix.length;
+    const n = matrix[0].length;
+    let left = 0;
+    let right = m * n;
+    while (left < right) {
+        const mid = (left + right) >>> 1;
+        const i = Math.floor(mid / n);
+        const j = mid % n;
+        if (matrix[i][j] === target) {
+            return true;
+        }
+
+        if (matrix[i][j] < target) {
+            left = mid + 1;
+        } else {
+            right = mid;
+        }
+    }
+    return false;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -306,6 +332,29 @@ impl Solution {
 }
 ```
 
+```rust
+use std::cmp::Ordering;
+impl Solution {
+    pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
+        let m = matrix.len();
+        let n = matrix[0].len();
+        let mut left = 0;
+        let mut right = m * n;
+        while left < right {
+            let mid = left + (right - left) / 2;
+            let i = mid / n;
+            let j = mid % n;
+            match matrix[i][j].cmp(&target) {
+                Ordering::Equal => return true,
+                Ordering::Less => left = mid + 1,
+                Ordering::Greater => right = mid,
+            }
+        }
+        false
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0074.Search a 2D Matrix/README_EN.md

@@ -236,6 +236,32 @@ func searchMatrix(matrix [][]int, target int) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function searchMatrix(matrix: number[][], target: number): boolean {
+    const m = matrix.length;
+    const n = matrix[0].length;
+    let left = 0;
+    let right = m * n;
+    while (left < right) {
+        const mid = (left + right) >>> 1;
+        const i = Math.floor(mid / n);
+        const j = mid % n;
+        if (matrix[i][j] === target) {
+            return true;
+        }
+
+        if (matrix[i][j] < target) {
+            left = mid + 1;
+        } else {
+            right = mid;
+        }
+    }
+    return false;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -258,6 +284,29 @@ impl Solution {
 }
 ```
 
+```rust
+use std::cmp::Ordering;
+impl Solution {
+    pub fn search_matrix(matrix: Vec<Vec<i32>>, target: i32) -> bool {
+        let m = matrix.len();
+        let n = matrix[0].len();
+        let mut left = 0;
+        let mut right = m * n;
+        while left < right {
+            let mid = left + (right - left) / 2;
+            let i = mid / n;
+            let j = mid % n;
+            match matrix[i][j].cmp(&target) {
+                Ordering::Equal => return true,
+                Ordering::Less => left = mid + 1,
+                Ordering::Greater => right = mid,
+            }
+        }
+        false
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0074.Search a 2D Matrix/Solution.ts

@@ -0,0 +1,21 @@
+function searchMatrix(matrix: number[][], target: number): boolean {
+    const m = matrix.length;
+    const n = matrix[0].length;
+    let left = 0;
+    let right = m * n;
+    while (left < right) {
+        const mid = (left + right) >>> 1;
+        const i = Math.floor(mid / n);
+        const j = mid % n;
+        if (matrix[i][j] === target) {
+            return true;
+        }
+
+        if (matrix[i][j] < target) {
+            left = mid + 1;
+        } else {
+            right = mid;
+        }
+    }
+    return false;
+}

solution/0000-0099/0078.Subsets/README.md

@@ -217,27 +217,46 @@ func subsets(nums []int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function subsets(nums: number[]): number[][] {
+    const n = nums.length;
+    const t: number[] = [];
+    const res: number[][] = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...t]);
+            return;
+        }
+        dfs(i + 1);
+        t.push(nums[i]);
+        dfs(i + 1);
+        t.pop();
+    };
+    dfs(0);
+    return res;
+}
+```
+
 ### **Rust**
 
 ```rust
 impl Solution {
-    fn dfs(nums: &Vec<i32>, res: &mut Vec<Vec<i32>>, i: usize, base: &mut Vec<i32>) {
-        let n = nums.len();
-        if i == n {
+    fn dfs(i: usize, t: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, nums: &Vec<i32>) {
+        if i == nums.len() {
+            res.push(t.clone());
             return;
         }
-        for j in i..n {
-            base.push(nums[j]);
-            res.push(base.clone());
-            Self::dfs(nums, res, j + 1, base);
-            base.pop();
-        }
+        Self::dfs(i + 1, t, res, nums);
+        t.push(nums[i]);
+        Self::dfs(i + 1, t, res, nums);
+        t.pop();
     }
 
     pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
-        let mut base = vec![];
-        let mut res = vec![vec![]];
-        Self::dfs(&nums, &mut res, 0, &mut base);
+        let mut res = Vec::new();
+        Self::dfs(0, &mut Vec::new(), &mut res, &nums);
         res
     }
 }

solution/0000-0099/0078.Subsets/README_EN.md

@@ -205,27 +205,46 @@ func subsets(nums []int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function subsets(nums: number[]): number[][] {
+    const n = nums.length;
+    const t: number[] = [];
+    const res: number[][] = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...t]);
+            return;
+        }
+        dfs(i + 1);
+        t.push(nums[i]);
+        dfs(i + 1);
+        t.pop();
+    };
+    dfs(0);
+    return res;
+}
+```
+
 ### **Rust**
 
 ```rust
 impl Solution {
-    fn dfs(nums: &Vec<i32>, res: &mut Vec<Vec<i32>>, i: usize, base: &mut Vec<i32>) {
-        let n = nums.len();
-        if i == n {
+    fn dfs(i: usize, path: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, nums: &Vec<i32>) {
+        if i == nums.len() {
+            res.push(path.clone());
             return;
         }
-        for j in i..n {
-            base.push(nums[j]);
-            res.push(base.clone());
-            Self::dfs(nums, res, j + 1, base);
-            base.pop();
-        }
+        Self::dfs(i + 1, path, res, nums);
+        path.push(nums[i]);
+        Self::dfs(i + 1, path, res, nums);
+        path.pop();
     }
 
     pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
-        let mut base = vec![];
-        let mut res = vec![vec![]];
-        Self::dfs(&nums, &mut res, 0, &mut base);
+        let mut res = Vec::new();
+        Self::dfs(0, &mut Vec::new(), &mut res, &nums);
         res
     }
 }

solution/0000-0099/0078.Subsets/Solution.rs

@@ -1,21 +1,18 @@
 impl Solution {
-    fn dfs(nums: &Vec<i32>, res: &mut Vec<Vec<i32>>, i: usize, base: &mut Vec<i32>) {
-        let n = nums.len();
-        if i == n {
+    fn dfs(i: usize, t: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, nums: &Vec<i32>) {
+        if i == nums.len() {
+            res.push(t.clone());
             return;
         }
-        for j in i..n {
-            base.push(nums[j]);
-            res.push(base.clone());
-            Self::dfs(nums, res, j + 1, base);
-            base.pop();
-        }
+        Self::dfs(i + 1, t, res, nums);
+        t.push(nums[i]);
+        Self::dfs(i + 1, t, res, nums);
+        t.pop();
     }
 
     pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
-        let mut base = vec![];
-        let mut res = vec![vec![]];
-        Self::dfs(&nums, &mut res, 0, &mut base);
+        let mut res = Vec::new();
+        Self::dfs(0, &mut Vec::new(), &mut res, &nums);
         res
     }
 }

solution/0000-0099/0078.Subsets/Solution.ts

@@ -0,0 +1,17 @@
+function subsets(nums: number[]): number[][] {
+    const n = nums.length;
+    const t: number[] = [];
+    const res: number[][] = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...t]);
+            return;
+        }
+        dfs(i + 1);
+        t.push(nums[i]);
+        dfs(i + 1);
+        t.pop();
+    };
+    dfs(0);
+    return res;
+}

solution/0000-0099/0090.Subsets II/README.md

@@ -148,6 +148,60 @@ func subsetsWithDup(nums []int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function subsetsWithDup(nums: number[]): number[][] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const t: number[] = [];
+    const res: number[][] = [];
+    const dfs = (i: number) => {
+        if (i === n) {
+            res.push([...t]);
+            return;
+        }
+        t.push(nums[i]);
+        dfs(i + 1);
+        const num = t.pop();
+        while (i < n && nums[i] == num) {
+            i++;
+        }
+        dfs(i);
+    };
+    dfs(0);
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(mut i: usize, t: &mut Vec<i32>, res: &mut Vec<Vec<i32>>, nums: &Vec<i32>) {
+        let n = nums.len();
+        if i == n {
+            res.push(t.clone());
+            return;
+        }
+        t.push(nums[i]);
+        Self::dfs(i + 1, t, res, nums);
+        let num = t.pop().unwrap();
+        while i < n && num == nums[i] {
+            i += 1;
+        }
+        Self::dfs(i, t, res, nums);
+    }
+
+    pub fn subsets_with_dup(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
+        nums.sort();
+        let mut res = Vec::new();
+        Self::dfs(0, &mut Vec::new(), &mut res, &nums);
+        res
+    }
+}
+```
+
 ### **...**
 
 ```