Smallest Rectangle Enclosing Black Pixels

Smallest Rectangle Enclosing Black Pixels - Problem

You are given an m x n binary matrix image where 0 represents a white pixel and 1 represents a black pixel.

The black pixels are connected (i.e., there is only one black region). Pixels are connected horizontally and vertically.

Given two integers x and y that represent the location of one of the black pixels, return the area of the smallest (axis-aligned) rectangle that encloses all black pixels.

You must write an algorithm with less than O(mn) runtime complexity.

Input & Output

Example 1 — Basic Connected Region

$ Input: image = [[0,0,1,0],[0,1,1,0],[0,1,0,0]], x = 0, y = 2

› Output: 6

💡 Note: Black pixels form connected region from (0,2) to (2,1). Rectangle bounds: rows [0,2], columns [1,2]. Area = (2-0+1) × (2-1+1) = 3 × 2 = 6

Example 2 — Single Black Pixel

$ Input: image = [[1]], x = 0, y = 0

› Output: 1

💡 Note: Only one black pixel at (0,0). Rectangle is 1×1, so area = 1

Example 3 — Horizontal Line

$ Input: image = [[1,1,1]], x = 0, y = 1

› Output: 3

💡 Note: Black pixels form horizontal line. Rectangle bounds: row [0,0], columns [0,2]. Area = 1 × 3 = 3

Constraints

m == image.length
n == image[i].length
1 ≤ m, n ≤ 100
image[i][j] is either 0 or 1
0 ≤ x < m
0 ≤ y < n
image[x][y] == 1

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 28 M Microsoft 23 A Amazon 19

The key insight is that since black pixels are connected, we can use binary search to find the boundaries instead of scanning every cell. The optimal approach uses binary search on rows and columns to find the rectangle boundaries. Time: O(m log n + n log m), Space: O(1).

Common Approaches

✓ Binary Search on Boundaries

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

Since black pixels are connected, use binary search to find the leftmost column, rightmost column, topmost row, and bottommost row containing black pixels. This avoids scanning the entire matrix.

Brute Force - Check All Cells

⏱️ Time: O(mn) Space: O(1)

Iterate through every cell in the matrix to find the leftmost, rightmost, topmost, and bottommost black pixels. Calculate area from these boundaries.

Binary Search on Boundaries — Algorithm Steps

Binary search on columns to find leftmost and rightmost boundaries
Binary search on rows to find topmost and bottommost boundaries
Calculate area from the four boundaries

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Left

Find leftmost column with black pixels

Binary Search Right

Find rightmost column with black pixels

Binary Search Top/Bottom

Find topmost and bottommost rows

Code -

solution.c — C

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

static int image[1000][1000];
static int colSizes[1000];
static int* imageRows[1000];

int searchLeft(int** image, int left, int right, int m) {
    while (left < right) {
        int mid = (left + right) / 2;
        bool hasBlack = false;
        for (int i = 0; i < m; i++) {
            if (image[i][mid] == 1) {
                hasBlack = true;
                break;
            }
        }
        if (hasBlack) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

int searchRight(int** image, int left, int right, int m) {
    while (left < right) {
        int mid = (left + right + 1) / 2;
        bool hasBlack = false;
        for (int i = 0; i < m; i++) {
            if (image[i][mid] == 1) {
                hasBlack = true;
                break;
            }
        }
        if (hasBlack) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    return left;
}

int searchTop(int** image, int top, int bottom, int n) {
    while (top < bottom) {
        int mid = (top + bottom) / 2;
        bool hasBlack = false;
        for (int j = 0; j < n; j++) {
            if (image[mid][j] == 1) {
                hasBlack = true;
                break;
            }
        }
        if (hasBlack) {
            bottom = mid;
        } else {
            top = mid + 1;
        }
    }
    return top;
}

int searchBottom(int** image, int top, int bottom, int n) {
    while (top < bottom) {
        int mid = (top + bottom + 1) / 2;
        bool hasBlack = false;
        for (int j = 0; j < n; j++) {
            if (image[mid][j] == 1) {
                hasBlack = true;
                break;
            }
        }
        if (hasBlack) {
            top = mid;
        } else {
            bottom = mid - 1;
        }
    }
    return top;
}

int solution(int** image, int imageSize, int* imageColSize, int x, int y) {
    if (imageSize == 0 || imageColSize[0] == 0) return 0;
    
    int m = imageSize, n = imageColSize[0];
    
    int left = searchLeft(image, 0, y, m);
    int right = searchRight(image, y, n - 1, m);
    int top = searchTop(image, 0, x, n);
    int bottom = searchBottom(image, x, m - 1, n);
    
    return (bottom - top + 1) * (right - left + 1);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array
    int m = 0, n = 0;
    char* ptr = line;
    
    // Skip first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr) {
        if (*ptr == '[') {
            // Start of a row
            ptr++;
            int col = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    char* endptr;
                    image[m][col] = (int)strtol(ptr, &endptr, 10);
                    ptr = endptr;
                    col++;
                } else {
                    ptr++;
                }
            }
            if (m == 0) n = col;
            colSizes[m] = col;
            imageRows[m] = image[m];
            m++;
            if (*ptr == ']') ptr++;
        } else if (*ptr == ']') {
            break;
        } else {
            ptr++;
        }
    }
    
    // Read x
    fgets(line, sizeof(line), stdin);
    int x = (int)strtol(line, NULL, 10);
    
    // Read y
    fgets(line, sizeof(line), stdin);
    int y = (int)strtol(line, NULL, 10);
    
    int result = solution(imageRows, m, colSizes, x, y);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log n + n log m)

Binary search on n columns requires O(log n) iterations, each checking m rows. Similarly for rows.

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for binary search bounds

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

987 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 on Boundaries — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler