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.

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

Visualization

Tap to expand

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

✓ Brute Force Enumeration

⏱️ Time: O(m⁶n⁶) Space: O(1)

Generate all possible rectangles in the grid and try every combination of 3 non-overlapping rectangles that cover all 1s. This approach examines every conceivable placement but is extremely inefficient.

Optimized Enumeration with Partitioning

⏱️ Time: O(m²n²) Space: O(1)

Instead of trying all possible rectangles, partition the grid using horizontal or vertical cuts and solve subproblems optimally. This reduces the complexity by leveraging the structure of the problem.

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>
#include <string.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** parseGrid(char* input, int* rows, int** colSizes) {
    int** grid = malloc(30 * sizeof(int*));
    *colSizes = malloc(30 * sizeof(int));
    *rows = 0;
    
    char* ptr = input + 1; // Skip initial '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            grid[*rows] = malloc(30 * sizeof(int));
            (*colSizes)[*rows] = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[*rows][(*colSizes)[*rows]] = *ptr - '0';
                    (*colSizes)[*rows]++;
                }
                ptr++;
            }
            (*rows)++;
        }
        ptr++;
    }
    return grid;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int rows;
    int* colSizes;
    int** grid = parseGrid(input, &rows, &colSizes);
    
    printf("%d\n", minimumSum(grid, rows, colSizes));
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    free(colSizes);
    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

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

Find the Minimum Area to Cover All Ones II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler