Search a 2D Matrix II

Search a 2D Matrix II - Problem

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 order from left to right.
• Integers in each column are sorted in ascending order from top to bottom.

Return true if target is found, otherwise return false.

Input & Output

Example 1 — Basic Search

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

› Output: true

💡 Note: Target 5 exists in the matrix at position (1,1). Using the optimal approach: start at top-right (11), 11 > 5 so move left to 7, 7 > 5 so move left to 4, 4 < 5 so move down to 5, found!

Example 2 — Target Not Found

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

› Output: false

💡 Note: Target 13 does not exist in the matrix. Starting from top-right, we would traverse through several cells but never find 13, eventually going out of bounds.

Example 3 — Single Element

$ Input: matrix = [[5]], target = 5

› Output: true

💡 Note: Edge case with single element matrix. The target 5 matches the only element in the matrix.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 28 A Apple 22

The key insight is to start from the top-right corner where we can eliminate either a row or column at each step. If current element is greater than target, move left; if smaller, move down. Best approach achieves O(m+n) time complexity using the sorted matrix property optimally.

Common Approaches

✓ Brute Force

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

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

Row-wise Binary Search

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

Since each row is sorted, we can use binary search on each row to find the target more efficiently than linear search.

Search Space Reduction

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

Start from top-right corner where we can make decisions to move left (if current > target) or down (if current < target), effectively eliminating one row or column at each step.

Brute Force — Algorithm Steps

Step 1: Iterate through each row
Step 2: For each row, check every column
Step 3: Return true if target found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at top-left corner

Scan

Check each element row by row

Result

Return true when target found

Code -

solution.c — C

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

bool solution(int** matrix, int matrixSize, int* matrixColSize, int target) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return false;
    }
    
    for (int i = 0; i < matrixSize; i++) {
        for (int j = 0; j < matrixColSize[i]; j++) {
            if (matrix[i][j] == target) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int target;
    scanf("%d", &target);
    
    int** matrix = (int**)malloc(300 * sizeof(int*));
    int matrixSize = 0, matrixColSize[300];
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    ptr++; // Skip first '['
    
    while (*ptr && matrixSize < 300) {
        if (*ptr == '[') {
            ptr++; // Skip '['
            matrix[matrixSize] = (int*)malloc(300 * sizeof(int));
            int col = 0;
            
            while (*ptr && *ptr != ']' && col < 300) {
                while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
                if (*ptr == ']') break;
                
                int num = 0, sign = 1;
                if (*ptr == '-') {
                    sign = -1;
                    ptr++;
                }
                while (*ptr >= '0' && *ptr <= '9') {
                    num = num * 10 + (*ptr - '0');
                    ptr++;
                }
                matrix[matrixSize][col++] = sign * num;
            }
            matrixColSize[matrixSize] = col;
            matrixSize++;
            
            while (*ptr && *ptr != ']') ptr++; // Find ']'
            if (*ptr) ptr++; // Skip ']'
        }
        while (*ptr && *ptr != '[' && *ptr != ']') ptr++;
        if (*ptr == ']') break;
    }
    
    bool result = solution(matrix, matrixSize, matrixColSize, target);
    printf(result ? "true\n" : "false\n");
    
    for (int i = 0; i < matrixSize; i++) {
        free(matrix[i]);
    }
    free(matrix);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit every element in the m×n matrix once

⚡ Linearithmic

Space Complexity

O(1)

Only use constant extra space for loop variables

✓ Linear Space

125.0K Views

High Frequency

~15 min Avg. Time

2.8K 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler