Search a 2D Matrix II - Practice Coding Problems

Search a 2D Matrix II - Problem

Imagine you have a cleverly organized library where books are arranged in a special way: each row is sorted by publication year (left to right), and each column is sorted by page count (top to bottom). Now you need to find a specific book efficiently!

Given an m x n integer matrix with the following properties:

Row-wise sorted: Integers in each row are in ascending order from left to right
Column-wise sorted: Integers in each column are in ascending order from top to bottom

Write an efficient algorithm to search for a target value. Return true if found, false otherwise.

Key Challenge: The matrix is partially sorted - it's not a simple 1D sorted array, but has structure we can exploit!

Input & Output

example_1.py — Standard Search

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

› Output: true

💡 Note: The target 5 exists in the matrix at position [1,1]. Using the optimal approach, we start from top-right (11), move left to 7, then down to 12, left to 8, down to 16, left to 9, down (out of bounds), left to 6, down (out of bounds), left to 3, down (out of bounds), left to 2, down to 5 - found!

example_2.py — Target Not Found

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

› Output: false

💡 Note: The target 13 does not exist in the matrix. Starting from top-right (11), we move down to 12, down to 16. Since 16 > 13, we move left to 9, but 9 < 13, so we move down (out of bounds). Search space exhausted without finding 13.

example_3.py — Single Element Matrix

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

› Output: true

💡 Note: Edge case with a single element matrix. The target 5 matches the only element in the matrix at position [0,0].

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 300
-10⁹ ≤ matrix[i][j] ≤ 10⁹
Each row is sorted in non-decreasing order
Each column is sorted in non-decreasing order
-10⁹ ≤ target ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Start Position

Begin at top-right corner - this position gives you maximum information

Smart Decision

If current > target, move left (eliminate column). If current < target, move down (eliminate row)

Eliminate Search Space

Each move eliminates an entire row or column, reducing search space efficiently

Find or Exhaust

Continue until target is found or search boundaries are exceeded

Key Takeaway

🎯 Key Insight: Starting from the top-right corner allows us to make optimal decisions at each step, eliminating entire rows or columns and achieving linear time complexity!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 25

The optimal solution uses the two-pointer technique starting from the top-right corner. This leverages both the row-wise and column-wise sorting properties to eliminate entire rows or columns with each comparison, achieving O(m + n) time complexity. The key insight is that from the top-right position, we can always make a definitive decision about which direction to move based on the comparison with the target.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Element)	O(m × n)	O(1)	Check every element in the matrix sequentially
Binary Search on Each Row	O(m log n)	O(1)	Apply binary search on each row independently
Smart Two Pointers (Top-Right Start)	O(m + n)	O(1)	Start from top-right corner and eliminate rows/columns intelligently

Brute Force (Check Every Element) — Algorithm Steps

Iterate through each row from top to bottom
For each row, iterate through each column from left to right
Compare current element with target
Return true if found, continue if not
Return false if entire matrix is searched

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from top-left

Begin checking from matrix[0][0]

Check each element

Compare current element with target

Move sequentially

Move row by row, left to right

Return result

Return true if found, false if entire matrix searched

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <cjson/cJSON.h>

bool searchMatrix(int** matrix, int matrixSize, int* matrixColSize, int target) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return false;
    }
    
    // Check every element
    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 buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    
    cJSON *json = cJSON_Parse(buffer);
    cJSON *matrixJson = cJSON_GetObjectItemCaseSensitive(json, "matrix");
    cJSON *targetJson = cJSON_GetObjectItemCaseSensitive(json, "target");
    
    int m = cJSON_GetArraySize(matrixJson);
    int n = cJSON_GetArraySize(cJSON_GetArrayItem(matrixJson, 0));
    
    int** matrix = (int**)malloc(m * sizeof(int*));
    int* matrixColSize = (int*)malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        cJSON *row = cJSON_GetArrayItem(matrixJson, i);
        matrixColSize[i] = cJSON_GetArraySize(row);
        matrix[i] = (int*)malloc(matrixColSize[i] * sizeof(int));
        for (int j = 0; j < matrixColSize[i]; j++) {
            matrix[i][j] = cJSON_GetArrayItem(row, j)->valueint;
        }
    }
    
    int target = targetJson->valueint;
    
    printf("%s\n", searchMatrix(matrix, m, matrixColSize, target) ? "true" : "false");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(matrix[i]);
    }
    free(matrix);
    free(matrixColSize);
    cJSON_Delete(json);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We potentially visit every element in the m×n matrix once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

42.0K Views

High Frequency

~15 min Avg. Time

1.6K 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 (Check Every Element) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler