Smallest Rectangle Enclosing Black Pixels

Smallest Rectangle Enclosing Black Pixels - Problem

Imagine you're working with a digital photograph represented as a binary matrix where 0 represents white pixels and 1 represents black pixels. You know that all black pixels form a single connected region (like a blob of ink on paper).

Your task is to find the smallest axis-aligned rectangle that completely encloses all the black pixels. Think of it like drawing the tightest possible rectangular frame around a shape.

Key constraints:

The matrix is m x n in size
All black pixels (1s) are connected horizontally or vertically
You're given the coordinates (x, y) of one black pixel as a starting point
Your algorithm must run in less than O(mn) time complexity

Return the area of the smallest rectangle that encloses all black pixels.

Input & Output

example_1.py — Basic Rectangle

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

› Output: 6

💡 Note: The black pixels form a shape from row 0-2 and columns 1-2, creating a 3×2 rectangle with area 6

example_2.py — Single Column

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

› Output: 3

💡 Note: All black pixels are in a single column, forming a 3×1 rectangle with area 3

example_3.py — L-shaped Region

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

› Output: 6

💡 Note: The L-shaped black region requires a 3×2 bounding rectangle with area 6

Visualization

Tap to expand

Understanding the Visualization

Identify the Subject

We know there's black ink at position (x,y) - this is our reference point

Smart Boundary Detection

Instead of checking every pixel, use binary search to quickly find edges

Search Left Edge

Binary search columns from 0 to y to find leftmost black pixels

Search Right Edge

Binary search columns from y to n-1 to find rightmost black pixels

Search Vertical Edges

Similarly find top and bottom boundaries using row searches

Calculate Frame Size

Multiply width × height to get the minimum rectangle area

Key Takeaway

🎯 Key Insight: By leveraging binary search and the connected region property, we can find rectangle boundaries in logarithmic time instead of linear time, achieving the required sub-O(mn) complexity while maintaining correctness.

Time & Space Complexity

Time Complexity

⏱️

O(m log n + n log m)

Four binary searches: 2 on columns (m comparisons each) and 2 on rows (n comparisons each)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search bounds

✓ Linear Space

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'
The black pixels in the image only form one component

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses binary search to find rectangle boundaries in O(m log n + n log m) time. Instead of scanning every cell, we perform four binary searches to find the leftmost, rightmost, topmost, and bottommost boundaries containing black pixels. This leverages the connected region property to achieve the required sub-O(mn) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Boundaries (Optimal)	O(m log n + n log m)	O(1)	Use binary search to find the leftmost, rightmost, topmost, and bottommost boundaries
Brute Force (Complete Grid Scan)	O(mn)	O(1)	Scan every cell in the matrix to find min/max boundaries

Binary Search on Boundaries (Optimal) — Algorithm Steps

Use the given (x,y) coordinates as our reference point
Binary search for the leftmost column containing black pixels
Binary search for the rightmost column containing black pixels
Binary search for the topmost row containing black pixels
Binary search for the bottommost row containing black pixels
Calculate area using the found boundaries

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Known Point

Use given (x,y) coordinates as reference

Search Left Boundary

Binary search columns 0 to y for leftmost black pixel

Search Right Boundary

Binary search columns y to n-1 for rightmost black pixel

Search Top/Bottom

Similarly search rows for top and bottom boundaries

Code -

solution.c — C

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

bool hasBlackInRow(char** image, int row, int cols) {
    for (int j = 0; j < cols; j++) {
        if (image[row][j] == '1') return true;
    }
    return false;
}

bool hasBlackInCol(char** image, int rows, int col) {
    for (int i = 0; i < rows; i++) {
        if (image[i][col] == '1') return true;
    }
    return false;
}

int binarySearchLeft(int left, int right, char** image, int rows, int cols, bool (*hasBlack)(char**, int, int), bool isRow) {
    while (left < right) {
        int mid = (left + right) / 2;
        if (isRow ? hasBlackInRow(image, mid, cols) : hasBlackInCol(image, rows, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

int binarySearchRight(int left, int right, char** image, int rows, int cols, bool (*hasBlack)(char**, int, int), bool isRow) {
    while (left < right) {
        int mid = (left + right + 1) / 2;
        if (isRow ? hasBlackInRow(image, mid, cols) : hasBlackInCol(image, rows, mid)) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    return left;
}

int minArea(char** image, int imageSize, int* imageColSize, int x, int y) {
    if (imageSize == 0 || imageColSize[0] == 0) return 0;
    
    int m = imageSize, n = imageColSize[0];
    
    int top = binarySearchLeft(0, x, image, m, n, hasBlackInRow, true);
    int bottom = binarySearchRight(x, m - 1, image, m, n, hasBlackInRow, true);
    int left = binarySearchLeft(0, y, image, m, n, hasBlackInCol, false);
    int right = binarySearchRight(y, n - 1, image, m, n, hasBlackInCol, false);
    
    return (bottom - top + 1) * (right - left + 1);
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log n + n log m)

Four binary searches: 2 on columns (m comparisons each) and 2 on rows (n comparisons each)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search bounds

✓ Linear Space

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'
The black pixels in the image only form one component

23.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Boundaries (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler