Search a 2D Matrix

Search a 2D Matrix - Problem

You are given an m x n integer matrix matrix with the following two properties:

Each row is sorted in non-decreasing order.
The first integer of each row is greater than the last integer of the previous row.

Given an integer target, return true if target is in matrix or false otherwise.

You must write a solution in O(log(m * n)) time complexity.

Input & Output

Example 1 — Basic Search

$ Input: matrix = [[1,4,7,11],[2,5,8,12],[3,6,9,16],[10,13,14,17]], target = 5

› Output: true

💡 Note: The target 5 exists in the matrix at position [1,1]. The matrix satisfies both properties: rows are sorted and first element of each row is greater than last element of previous row.

Example 2 — Target Not Found

$ Input: matrix = [[1,4,7,11],[2,5,8,12],[3,6,9,16],[10,13,14,17]], target = 13

› Output: true

💡 Note: The target 13 exists in the matrix at position [3,1]. Even though it's in the last row, binary search efficiently finds it in O(log(m*n)) time.

Example 3 — Target Not Present

$ Input: matrix = [[1,4,7,11],[2,5,8,12],[3,6,9,16],[10,13,14,17]], target = 15

› Output: false

💡 Note: The target 15 does not exist anywhere in the matrix. Binary search efficiently determines this without checking all elements.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 100
-10⁴ ≤ matrix[i][j], target ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 Apple 25

The key insight is that a sorted matrix with the given properties can be treated as a single sorted 1D array. The optimal approach uses binary search by mapping 2D coordinates to 1D indices: row = mid / n and col = mid % n. Time: O(log(m*n)), Space: O(1).

Common Approaches

✓ Binary Search (Treat as 1D Array)

⏱️ Time: O(log(m*n)) Space: O(1)

Since the matrix is sorted row-wise and the first element of each row is greater than the last of previous row, we can treat it as a single sorted array and apply binary search by converting between 2D and 1D indices.

Linear Search

⏱️ Time: O(m*n) Space: O(1)

Iterate through each row and each column, comparing every element with the target until found or all elements are checked.

Search Row Then Column

⏱️ Time: O(log m + log n) Space: O(1)

Use binary search to find the row that could contain the target (by comparing with first and last elements of each row), then use binary search within that row to find the target.

Binary Search (Treat as 1D Array) — Algorithm Steps

Step 1: Calculate total elements (m * n)
Step 2: Use binary search on virtual 1D array
Step 3: Convert 1D index back to 2D coordinates (row = mid/n, col = mid%n)

Visualization

Tap to expand

Step-by-Step Walkthrough

Map to 1D

Convert matrix[i][j] to index i*n+j

Binary Search

Use binary search on virtual 1D array

Convert Back

Map 1D index back to 2D: row=mid/n, col=mid%n

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

static int matrix[100][100];
static int rows, cols;

bool solution(int target) {
    if (rows == 0 || cols == 0) {
        return false;
    }
    
    // Search each row using binary search
    for (int i = 0; i < rows; i++) {
        // Check if target could be in this row
        if (target >= matrix[i][0] && target <= matrix[i][cols-1]) {
            // Binary search within this row
            int left = 0, right = cols - 1;
            while (left <= right) {
                int mid = left + (right - left) / 2;
                if (matrix[i][mid] == target) {
                    return true;
                } else if (matrix[i][mid] < target) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse matrix using strtol
    rows = 0;
    cols = 0;
    char *ptr = line;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr) {
        // Skip '['
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++;
        
        cols = 0;
        while (*ptr && *ptr != ']') {
            char *endptr;
            long val = strtol(ptr, &endptr, 10);
            if (endptr != ptr) {
                matrix[rows][cols] = (int)val;
                cols++;
                ptr = endptr;
            }
            while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        }
        
        if (cols > 0) rows++;
        
        // Skip ']'
        if (*ptr == ']') ptr++;
        
        // Check if we're at the end
        while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
        if (*ptr == ']') break;
    }
    
    int target;
    scanf("%d", &target);
    
    bool result = solution(target);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(m*n))

Binary search divides search space in half each iteration

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

67.5K Views

High Frequency

~15 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search (Treat as 1D Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler