Find the Minimum Area to Cover All Ones I

Find the Minimum Area to Cover All Ones I - Problem

Array Matrix Medium

Find the Minimum Area to Cover All Ones I

You are given a 2D binary grid where each cell contains either 0 or 1. Your task is to find the smallest possible rectangle that can enclose all the 1s in the grid.

Think of it as finding the tightest bounding box around all the "active" cells. The rectangle must have horizontal and vertical sides (axis-aligned), and you need to return the minimum possible area of such a rectangle.

Goal: Calculate the area of the smallest axis-aligned rectangle that contains all 1s
Input: A 2D binary array grid
Output: An integer representing the minimum area

Input & Output

example_1.py — Basic Rectangle

$ Input: grid = [[0,1,0],[1,0,1]]

› Output: 6

💡 Note: The 1s are at positions (0,1), (1,0), and (1,2). The minimum rectangle covers from row 0 to row 1 and from column 0 to column 2, giving us area = (1-0+1) × (2-0+1) = 2 × 3 = 6.

example_2.py — Single Row

$ Input: grid = [[1,0],[0,0]]

› Output: 1

💡 Note: There's only one 1 at position (0,0). The minimum rectangle is just this single cell with area = 1 × 1 = 1.

example_3.py — Full Coverage

$ Input: grid = [[1,1],[1,1]]

› Output: 4

💡 Note: All cells contain 1s. The minimum rectangle must cover the entire grid, so area = 2 × 2 = 4.

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is either 0 or 1
There is at least one 1 in grid

Visualization

Tap to expand

Key Insight: The optimal rectangle is always defined by the extreme positions of 1s

Understanding the Visualization

Scan the Photo

Go through every pixel in the image systematically

Mark Important Objects

When we find an important object (1), note its position

Track Extremes

Keep track of the topmost, bottommost, leftmost, and rightmost objects

Draw Crop Rectangle

The perfect crop is defined by these extreme boundaries

Key Takeaway

🎯 Key Insight: The minimum bounding rectangle is always determined by the four extreme positions (top, bottom, left, right) where 1s appear. We don't need to check every possible rectangle - just find these boundaries!

Asked in

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

The optimal approach uses boundary detection in a single pass through the grid. We track the minimum and maximum row/column indices of all 1s, then calculate the area as (maxRow - minRow + 1) × (maxCol - minCol + 1). This achieves O(mn) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass (Boundary Detection)	O(mn)	O(1)	Find extreme boundaries of all 1s in one pass through the grid

Optimized Single Pass (Boundary Detection) — Algorithm Steps

Initialize boundary variables: minRow, maxRow, minCol, maxCol
Scan through the entire grid once
For each cell containing 1, update the appropriate boundary variables
Calculate area as (maxRow - minRow + 1) × (maxCol - minCol + 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Boundaries

Set minRow=∞, maxRow=-1, minCol=∞, maxCol=-1

Scan Grid

Go through each cell from top-left to bottom-right

Update Boundaries

When we find a 1, update the appropriate min/max values

Calculate Area

Area = (maxRow - minRow + 1) × (maxCol - minCol + 1)

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int minimumArea(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int m = gridSize, n = gridColSize[0];
    
    // Initialize boundaries to impossible values
    int minRow = m, maxRow = -1;
    int minCol = n, maxCol = -1;
    
    // Single pass to find boundaries
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                if (i < minRow) minRow = i;
                if (i > maxRow) maxRow = i;
                if (j < minCol) minCol = j;
                if (j > maxCol) maxCol = j;
            }
        }
    }
    
    // If no 1s found
    if (maxRow == -1) return 0;
    
    // Calculate minimum area
    return (maxRow - minRow + 1) * (maxCol - minCol + 1);
}

int main() {
    printf("Single pass optimal solution\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Single pass through all cells in the m×n grid

✓ Linear Growth

Space Complexity

O(1)

Only storing four boundary variables regardless of input size

✓ Linear Space

52.0K Views

Medium-High Frequency

~12 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

Optimized Single Pass (Boundary Detection) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler