feat: add solutions to lcci problem: No.10.09 (#2699)

Author: yanglbme

lcci/10.09.Sorted Matrix Search/README.md

@@ -26,14 +26,177 @@
 
 ## 解法
 
-### 方法一
+### 方法一：二分查找
+
+由于每一行的所有元素升序排列，因此，对于每一行，我们可以使用二分查找找到第一个大于等于 `target` 的元素，然后判断该元素是否等于 `target`。如果等于 `target`，说明找到了目标值，直接返回 `true`。如果不等于 `target`，说明这一行的所有元素都小于 `target`，应该继续搜索下一行。
+
+如果所有行都搜索完了，都没有找到目标值，说明目标值不存在，返回 `false`。
+
+时间复杂度 $O(m \times \log n)$，其中 $m$ 和 $n$ 分别为矩阵的行数和列数。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+```python
+class Solution:
+    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
+        for row in matrix:
+            j = bisect_left(row, target)
+            if j < len(matrix[0]) and row[j] == target:
+                return True
+        return False
+```
+
+```java
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        for (var row : matrix) {
+            int j = Arrays.binarySearch(row, target);
+            if (j >= 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>>& matrix, int target) {
+        for (auto& row : matrix) {
+            int j = lower_bound(row.begin(), row.end(), target) - row.begin();
+            if (j < matrix[0].size() && row[j] == target) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+```
+
+```go
+func searchMatrix(matrix [][]int, target int) bool {
+	for _, row := range matrix {
+		j := sort.SearchInts(row, target)
+		if j < len(matrix[0]) && row[j] == target {
+			return true
+		}
+	}
+	return false
+}
+```
+
+```ts
+function searchMatrix(matrix: number[][], target: number): boolean {
+    const n = matrix[0].length;
+    for (const row of matrix) {
+        let left = 0,
+            right = n;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (row[mid] >= target) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        if (left != n && row[left] == target) {
+            return true;
+        }
+    }
+    return false;
+}
+```
+
+```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 i = 0;
+        let mut j = n;
+        while i < m && j > 0 {
+            match target.cmp(&matrix[i][j - 1]) {
+                Ordering::Less => {
+                    j -= 1;
+                }
+                Ordering::Greater => {
+                    i += 1;
+                }
+                Ordering::Equal => {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+}
+```
+
+```js
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function (matrix, target) {
+    const n = matrix[0].length;
+    for (const row of matrix) {
+        let left = 0,
+            right = n;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (row[mid] >= target) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        if (left != n && row[left] == target) {
+            return true;
+        }
+    }
+    return false;
+};
+```
+
+```cs
+public class Solution {
+    public bool SearchMatrix(int[][] matrix, int target) {
+        foreach (int[] row in matrix) {
+            int j = Array.BinarySearch(row, target);
+            if (j >= 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+```
+
+<!-- tabs:end -->
+
+### 方法二：从左下角或右上角搜索
+
+这里我们以左下角作为起始搜索点，往右上方向开始搜索，比较当前元素 `matrix[i][j]`与 `target` 的大小关系：
+
+-   若 $\text{matrix}[i][j] = \text{target}$，说明找到了目标值，直接返回 `true`。
+-   若 $\text{matrix}[i][j] > \text{target}$，说明这一列从当前位置开始往上的所有元素均大于 `target`，应该让 $i$ 指针往上移动，即 $i \leftarrow i - 1$。
+-   若 $\text{matrix}[i][j] < \text{target}$，说明这一行从当前位置开始往右的所有元素均小于 `target`，应该让 $j$ 指针往右移动，即 $j \leftarrow j + 1$。
+
+若搜索结束依然找不到 `target`，返回 `false`。
+
+时间复杂度 $O(m + n)$，其中 $m$ 和 $n$ 分别为矩阵的行数和列数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ```python
 class Solution:
     def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
-        if not matrix or not matrix[0]:
+        if not matrix:
             return False
         m, n = len(matrix), len(matrix[0])
         i, j = m - 1, 0
@@ -50,7 +213,7 @@ class Solution:
 ```java
 class Solution {
     public boolean searchMatrix(int[][] matrix, int target) {
-        if (matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0) {
+        if (matrix == null || matrix.length == 0) {
             return false;
         }
         int m = matrix.length, n = matrix[0].length;
@@ -74,15 +237,20 @@ class Solution {
 class Solution {
 public:
     bool searchMatrix(vector<vector<int>>& matrix, int target) {
-        if (matrix.size() == 0 || matrix[0].size() == 0) return false;
+        if (matrix.empty()) {
+            return false;
+        }
         int m = matrix.size(), n = matrix[0].size();
         int i = m - 1, j = 0;
         while (i >= 0 && j < n) {
-            if (matrix[i][j] == target) return true;
-            if (matrix[i][j] > target)
+            if (matrix[i][j] == target) {
+                return true;
+            }
+            if (matrix[i][j] > target) {
                 --i;
-            else
+            } else {
                 ++j;
+            }
         }
         return false;
     }
@@ -91,7 +259,7 @@ public:
 
 ```go
 func searchMatrix(matrix [][]int, target int) bool {
-	if len(matrix) == 0 || len(matrix[0]) == 0 {
+	if len(matrix) == 0 {
 		return false
 	}
 	m, n := len(matrix), len(matrix[0])
@@ -110,6 +278,50 @@ func searchMatrix(matrix [][]int, target int) bool {
 }
 ```
 
+```ts
+function searchMatrix(matrix: number[][], target: number): boolean {
+    if (matrix.length === 0) {
+        return false;
+    }
+    const [m, n] = [matrix.length, matrix[0].length];
+    let [i, j] = [m - 1, 0];
+    while (i >= 0 && j < n) {
+        if (matrix[i][j] === target) {
+            return true;
+        }
+        if (matrix[i][j] > target) {
+            --i;
+        } else {
+            ++j;
+        }
+    }
+    return false;
+}
+```
+
+```cs
+public class Solution {
+    public bool SearchMatrix(int[][] matrix, int target) {
+        if (matrix.Length == 0) {
+            return false;
+        }
+        int m = matrix.Length, n = matrix[0].Length;
+        int i = m - 1, j = 0;
+        while (i >= 0 && j < n) {
+            if (matrix[i][j] == target) {
+                return true;
+            }
+            if (matrix[i][j] > target) {
+                --i;
+            } else {
+                ++j;
+            }
+        }
+        return false;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->