Find the Minimum Area to Cover All Ones II

Find the Minimum Area to Cover All Ones II - Problem

You're given a 2D binary grid containing 0s and 1s. Your mission is to find exactly 3 non-overlapping rectangles that together cover all the 1s in the grid with the minimum total area.

Think of this as placing three rectangular stickers on a grid to cover all the marked spots (1s) while using as little sticker material as possible. The rectangles:

Must have non-zero areas (can't be empty)
Cannot overlap each other
Are allowed to touch at edges
Must have horizontal and vertical sides (axis-aligned)

Goal: Return the minimum possible sum of areas of these three rectangles.

Input & Output

example_1.py — Basic Grid

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

› Output: 5

💡 Note: We can place 3 rectangles: (0,0)-(0,0) covering grid[0][0]=1 with area 1, (0,2)-(0,2) covering grid[0][2]=1 with area 1, and (1,0)-(1,2) covering the bottom row with area 3. Total area = 1+1+3 = 5.

example_2.py — Sparse Grid

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

› Output: 5

💡 Note: Optimal placement uses 3 rectangles: (0,0)-(0,0) for grid[0][0], (0,2)-(1,3) covering the right portion, and (1,1)-(1,1) for grid[1][1]. This gives areas 1+4+1 = 6. Better solution: use vertical strips.

example_3.py — Clustered Pattern

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

› Output: 4

💡 Note: All 1s form a 2×2 cluster. We need exactly 3 rectangles with non-zero areas. Minimum is to use three 1×1 rectangles covering 3 cells (area=3) plus one 1×1 rectangle covering the remaining cell (area=1), but we need exactly 3. Optimal: split into regions giving total area 4.

Visualization

Tap to expand

Understanding the Visualization

Identify Target Area

Find the minimal bounding box containing all 1s (important locations)

Strategic Cuts

Try different ways to partition this area: 3 horizontal strips, 3 vertical strips, or mixed approaches

Optimize Each Region

For each partition, find the smallest rectangle that covers all 1s in that region

Compare Strategies

Test all partitioning strategies and return the one with minimum total area

Key Takeaway

🎯 Key Insight: Instead of trying all possible rectangle combinations, strategically partition the grid using cuts and solve optimally for each region, reducing complexity from exponential to polynomial time.

Time & Space Complexity

Time Complexity

⏱️

O(m⁶n⁶)

For each of 3 rectangles, we need O(m²n²) possible rectangles, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(1)

Only storing current best result and temporary variables

✓ Linear Space

Constraints

1 ≤ grid.length ≤ 30
1 ≤ grid[0].length ≤ 30
grid[i][j] is either 0 or 1
At least 1 cell contains 1
The grid will always have a valid solution

Asked in

G Google 24 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses strategic partitioning to reduce complexity from O(m⁶n⁶) to O(m²n²). Key insight: instead of trying all possible rectangles, partition the bounding box of all 1s using horizontal cuts, vertical cuts, or mixed strategies. For each partition, find the minimum rectangle covering all 1s in that region. This guarantees optimality while being much more efficient than brute force enumeration.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(m⁶n⁶)	O(1)	Try all possible ways to place 3 rectangles and find minimum area
Optimized Enumeration with Partitioning	O(m²n²)	O(1)	Use strategic partitioning to reduce the search space significantly

Brute Force Enumeration — Algorithm Steps

Find bounding box of all 1s in the grid
Generate all possible rectangles within this bounding box
For each combination of 3 rectangles, check if they're non-overlapping
Verify that all 1s are covered by at least one rectangle
Track the minimum total area found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All 1s

Locate all positions containing 1s in the grid

Generate Rectangles

Create all possible rectangles in the grid

Test Combinations

Try every combination of 3 non-overlapping rectangles

Verify Coverage

Check if all 1s are covered by at least one rectangle

Track Minimum

Keep track of the combination with minimum total area

Code -

solution.c — C

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

int getArea(int r1, int c1, int r2, int c2) {
    return (r2 - r1 + 1) * (c2 - c1 + 1);
}

int overlap(int* a, int* b) {
    return !(a[2] < b[0] || b[2] < a[0] || a[3] < b[1] || b[3] < a[1]);
}

int covers(int r, int c, int* rect) {
    return rect[0] <= r && r <= rect[2] && rect[1] <= c && c <= rect[3];
}

int minimumSum(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    int ones[100][2];
    int oneCount = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                ones[oneCount][0] = i;
                ones[oneCount][1] = j;
                oneCount++;
            }
        }
    }
    
    int minArea = INT_MAX;
    
    for (int r1 = 0; r1 < m; r1++) {
        for (int c1 = 0; c1 < n; c1++) {
            for (int r2 = r1; r2 < m; r2++) {
                for (int c2 = c1; c2 < n; c2++) {
                    int rect1[4] = {r1, c1, r2, c2};
                    for (int r3 = 0; r3 < m; r3++) {
                        for (int c3 = 0; c3 < n; c3++) {
                            for (int r4 = r3; r4 < m; r4++) {
                                for (int c4 = c3; c4 < n; c4++) {
                                    int rect2[4] = {r3, c3, r4, c4};
                                    if (overlap(rect1, rect2)) continue;
                                    
                                    for (int r5 = 0; r5 < m; r5++) {
                                        for (int c5 = 0; c5 < n; c5++) {
                                            for (int r6 = r5; r6 < m; r6++) {
                                                for (int c6 = c5; c6 < n; c6++) {
                                                    int rect3[4] = {r5, c5, r6, c6};
                                                    if (overlap(rect1, rect3) || overlap(rect2, rect3)) continue;
                                                    
                                                    int allCovered = 1;
                                                    for (int k = 0; k < oneCount; k++) {
                                                        if (!covers(ones[k][0], ones[k][1], rect1) &&
                                                            !covers(ones[k][0], ones[k][1], rect2) &&
                                                            !covers(ones[k][0], ones[k][1], rect3)) {
                                                            allCovered = 0;
                                                            break;
                                                        }
                                                    }
                                                    
                                                    if (allCovered) {
                                                        int area = getArea(r1, c1, r2, c2) + 
                                                                  getArea(r3, c3, r4, c4) + 
                                                                  getArea(r5, c5, r6, c6);
                                                        if (area < minArea) {
                                                            minArea = area;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    return minArea;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m⁶n⁶)

For each of 3 rectangles, we need O(m²n²) possible rectangles, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(1)

Only storing current best result and temporary variables

✓ Linear Space

Constraints

1 ≤ grid.length ≤ 30
1 ≤ grid[0].length ≤ 30
grid[i][j] is either 0 or 1
At least 1 cell contains 1
The grid will always have a valid solution

24.3K Views

Medium Frequency

~25 min Avg. Time

856 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

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler