LeetCode 0240. Search a 2D Matrix II Solution in Java, C++, Python & More | Explanation + Code

Description

Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:

• Integers in each row are sorted in ascending from left to right.
• Integers in each column are sorted in ascending from top to bottom.

 

Example 1:

Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
Output: true

Example 2:

Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
Output: false

 

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= n, m <= 300
• -109 <= matrix[i][j] <= 109
• All the integers in each row are sorted in ascending order.
• All the integers in each column are sorted in ascending order.
• -109 <= target <= 109

Solutions

Solution 1: Binary Search

Since all elements in each row are sorted in ascending order, for each row, we can use binary search to find the first element greater than or equal to target, and then check if that element is equal to target. If it is equal to target, it means the target value is found, and we return true. If it is not equal to target, it means all elements in this row are less than target, and we should continue searching the next row.

If all rows have been searched and the target value is not found, it means the target value does not exist, and we return false.

The time complexity is O(m × log n), where m and n are the number of rows and columns of the matrix, respectively. The space complexity is O(1).

PythonJavaC++GoTypeScriptRustJavaScriptC#

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(code-box)

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; } }(code-box)

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; } };(code-box)

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 }(code-box)

function searchMatrix(matrix: number[][], target: number): boolean { const n = matrix[0].length; for (const row of matrix) { const j = _.sortedIndex(row, target); if (j < n && row[j] === target) { return true; } } return false; }(code-box)

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 } }(code-box)

/** * @param {number[][]} matrix * @param {number} target * @return {boolean} */ var searchMatrix = function (matrix, target) { const n = matrix[0].length; for (const row of matrix) { const j = _.sortedIndex(row, target); if (j < n && row[j] == target) { return true; } } return false; };(code-box)

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; } }(code-box)

Solution 2: Search from Bottom-Left or Top-Right

We start the search from the bottom-left or top-right corner and move towards the top-right or bottom-left direction. Compare the current element matrix[i][j] with target:

• If matrix[i][j] = target, it means the target value is found, and we return true.
• If matrix[i][j] > target, it means all elements in this column from the current position upwards are greater than target, so we move the i pointer upwards, i.e., i \leftarrow i - 1.
• If matrix[i][j] < target, it means all elements in this row from the current position to the right are less than target, so we move the j pointer to the right, i.e., j \leftarrow j + 1.

If the search ends and the target is not found, return false.

The time complexity is O(m + n), where m and n are the number of rows and columns of the matrix, respectively. The space complexity is O(1).

PythonJavaC++GoTypeScriptRustC#

class Solution: def searchMatrix(self, matrix: List[List[int]], target: int) -> bool: m, n = len(matrix), len(matrix[0]) i, j = m - 1, 0 while i >= 0 and j < n: if matrix[i][j] == target: return True if matrix[i][j] > target: i -= 1 else: j += 1 return False(code-box)

class Solution { public boolean searchMatrix(int[][] matrix, int target) { 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; } }(code-box)

class Solution { public: bool searchMatrix(vector<vector<int>>& matrix, int target) { 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) { --i; } else { ++j; } } return false; } };(code-box)

func searchMatrix(matrix [][]int, target int) bool { m, n := len(matrix), len(matrix[0]) i, j := m-1, 0 for i >= 0 && j < n { if matrix[i][j] == target { return true } if matrix[i][j] > target { i-- } else { j++ } } return false }(code-box)

function searchMatrix(matrix: number[][], target: number): boolean { 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; }(code-box)

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 = m - 1; let mut j = 0; while i >= 0 && j < n { if matrix[i][j] == target { return true; } if matrix[i][j] > target { if i == 0 { break; } i -= 1; } else { j += 1; } } false } }(code-box)

public class Solution { public bool SearchMatrix(int[][] matrix, int target) { 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; } }(code-box)