Minimum Rectangles to Cover Points - Practice Coding Problems

Minimum Rectangles to Cover Points - Problem

Imagine you're a city planner tasked with covering specific locations with rectangular zones. You have a set of 2D points representing important locations, and you need to cover all of them using the minimum number of rectangles.

Given a 2D integer array points where points[i] = [x_i, y_i] and an integer w, your task is to cover all points with rectangles that:

Have their lower edge at y = 0 (ground level)
Extend from (x1, 0) to (x2, y2) where x1 ≤ x2 and y2 ≥ 0
Have a maximum width constraint: x2 - x1 ≤ w

A point is covered if it lies within or on the boundary of a rectangle. Points can be covered by multiple rectangles. Return the minimum number of rectangles needed to cover all points.

Example: If you have points [(0,1), (1,1), (5,1)] and w=2, you need at least 2 rectangles: one covering (0,1) and (1,1), and another covering (5,1).

Input & Output

example_1.py — Basic Case

$ Input: points = [[2,1],[1,0],[1,4],[1,8],[3,5],[4,6]], w = 1

› Output: 2

💡 Note: After sorting by x-coordinate: [(1,0),(1,4),(1,8),(2,1),(3,5),(4,6)]. First rectangle covers points at x=1 and x=2 (width=1). Second rectangle covers points at x=3 and x=4 (width=1).

example_2.py — Wide Coverage

$ Input: points = [[0,0],[1,1],[2,2]], w = 2

› Output: 1

💡 Note: All points have x-coordinates from 0 to 2, which fits within a single rectangle of width 2. One rectangle from (0,0) to (2,∞) covers all points.

example_3.py — Scattered Points

$ Input: points = [[0,0],[5,0],[10,0]], w = 3

› Output: 2

💡 Note: Points are at x=0, x=5, x=10. First rectangle covers x=0 with width 3 (covers x=0 to x=3). Second rectangle covers x=5 with width 3 (covers x=5 to x=8), but x=10 needs a third rectangle... Actually, we need one rectangle covering x=0 and another covering x=5 and x=10 - but x=10-x=5 = 5 > 3, so we need separate rectangles for x=5 and x=10. Total: 3 rectangles.

Visualization

Tap to expand

Understanding the Visualization

Sort Locations

Arrange all points by x-coordinate to process them systematically from left to right

Greedy Placement

For each uncovered point, place a rectangle and extend it as far right as the width constraint allows

Maximize Coverage

Each rectangle covers all points within its width, minimizing the total number needed

Optimal Solution

This greedy approach guarantees the minimum number of rectangles

Key Takeaway

🎯 Key Insight: After sorting by x-coordinate, we can greedily place each rectangle to start at the leftmost uncovered point and extend as far right as possible within the width constraint. This guarantees the minimum number of rectangles.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

We try all possible subsets of points (2^n) and for each subset check validity (O(n))

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary storage for combinations

⚡ Linearithmic Space

Constraints

1 ≤ points.length ≤ 10⁵
points[i].length == 2
0 ≤ x_i, y_i ≤ 10⁹
0 ≤ w ≤ 10⁹
Note: Only x-coordinates matter for rectangle placement

Asked in

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

The optimal solution uses a greedy approach with sorting. First, sort all points by their x-coordinates. Then iterate through the sorted points and for each uncovered point, place a rectangle starting at that point and extend it rightward to cover all points within the width constraint w. This ensures we use the minimum number of rectangles with O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n)	O(n)	Generate all possible rectangle placements and find minimum combination
Greedy with Sorting (Optimal)	O(n log n)	O(1)	Sort points by x-coordinate and greedily place rectangles from left to right

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible ways to group points into rectangles
For each grouping, check if rectangles are valid (width ≤ w)
Track the minimum number of rectangles needed
Return the minimum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Generate all possible subsets of points to try as single rectangles

Check Validity

For each subset, check if it can be covered by a single rectangle of width ≤ w

Recurse

For valid rectangles, recursively solve for remaining uncovered points

Find Minimum

Track and return the minimum number of rectangles found

Code -

solution.c — C

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

int canCover(int points[][2], int indices[], int count, int w) {
    if (count == 0) return 1;
    int minX = points[indices[0]][0], maxX = points[indices[0]][0];
    for (int i = 0; i < count; i++) {
        int x = points[indices[i]][0];
        if (x < minX) minX = x;
        if (x > maxX) maxX = x;
    }
    return maxX - minX <= w;
}

int backtrack(int points[][2], int n, int rectanglesUsed, int w) {
    if (n == 0) return rectanglesUsed;
    
    int minRectangles = INT_MAX;
    
    for (int mask = 1; mask < (1 << n); mask++) {
        int subset[20], remaining[20];
        int subsetCount = 0, remainingCount = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subset[subsetCount++] = i;
            } else {
                remaining[remainingCount++] = i;
            }
        }
        
        if (canCover(points, subset, subsetCount, w)) {
            int remainingPoints[20][2];
            for (int i = 0; i < remainingCount; i++) {
                remainingPoints[i][0] = points[remaining[i]][0];
                remainingPoints[i][1] = points[remaining[i]][1];
            }
            
            int result = backtrack(remainingPoints, remainingCount, rectanglesUsed + 1, w);
            if (result < minRectangles) {
                minRectangles = result;
            }
        }
    }
    
    return minRectangles;
}

int minRectanglesToCoverPoints(int points[][2], int n, int w) {
    return backtrack(points, n, 0, w);
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

We try all possible subsets of points (2^n) and for each subset check validity (O(n))

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary storage for combinations

⚡ Linearithmic Space

Constraints

1 ≤ points.length ≤ 10⁵
points[i].length == 2
0 ≤ x_i, y_i ≤ 10⁹
0 ≤ w ≤ 10⁹
Note: Only x-coordinates matter for rectangle placement

24.7K Views

Medium Frequency

~25 min Avg. Time

847 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler