Perfect Rectangle - Practice Coding Problems

Perfect Rectangle - Problem

Array Hash Table Math Geometry Line Sweep Hard

Perfect Rectangle is a fascinating geometric puzzle that tests your ability to work with coordinate geometry and hash tables. You're given an array of rectangles, where each rectangle is represented by four coordinates: [x1, y1, x2, y2] representing the bottom-left point (x1, y1) and top-right point (x2, y2).

Your task is to determine whether all these rectangles together form exactly one perfect rectangular region with no gaps and no overlaps. Think of it like a jigsaw puzzle - all pieces must fit together perfectly to form one complete rectangle.

Key Requirements:
• No gaps between rectangles
• No overlapping areas
• The combined shape must be exactly one rectangle
• All input rectangles must be used

Input & Output

example_1.py — Valid Perfect Rectangle

$ Input: rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]

› Output: true

💡 Note: These 5 rectangles perfectly form a 3×3 square from (1,1) to (4,4) with no gaps or overlaps. Each internal corner appears an even number of times, while the four outer corners (1,1), (4,1), (1,4), (4,4) appear exactly once.

example_2.py — Invalid - Has Gap

$ Input: rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]

› Output: false

💡 Note: These rectangles don't form a perfect rectangle because there's a gap in the region from (2,1) to (3,4). The total area of rectangles (5) doesn't match the expected bounding rectangle area (9).

example_3.py — Invalid - Has Overlap

$ Input: rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]

› Output: false

💡 Note: The last rectangle [2,2,4,4] overlaps with the first rectangle [1,1,3,3] in the region (2,2) to (3,3). This creates overlapping area, violating the perfect rectangle condition.

Visualization

Tap to expand

Understanding the Visualization

Collect Pieces

Gather all rectangle pieces and identify their corner points

Track Corners

Use a hash set to track how many times each corner point appears

Cancel Internal

Internal corners appear even times and cancel out from the set

Verify Result

Only 4 outer corners should remain, forming the perfect rectangle boundary

Key Takeaway

🎯 Key Insight: In a perfect rectangle cover, internal corner points appear an even number of times and cancel out, leaving exactly 4 boundary corners that appear once each.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all rectangles, with O(1) hash set operations per rectangle

✓ Linear Growth

Space Complexity

O(n)

Hash set can contain up to 4n corner points in worst case (though typically much less)

⚡ Linearithmic Space

Constraints

1 ≤ rectangles.length ≤ 2 × 10⁴
rectangles[i].length == 4
-10⁵ ≤ x_i, y_i, a_i, b_i ≤ 10⁵
All rectangles are axis-aligned and have positive area

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses a corner point hash set to track rectangle corners. In a perfect rectangle cover, internal corners appear an even number of times (2 or 4) and cancel out, while only the four outer corners appear exactly once. This approach runs in O(n) time and elegantly handles all edge cases including gaps and overlaps.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Area Check	O(n²)	O(1)	Calculate total area and check for overlaps by comparing all rectangle pairs
One-Pass Corner Point Hash (Optimal)	O(n)	O(n)	Track corner point frequencies in a hash set - valid rectangles have specific corner patterns

Brute Force Area Check — Algorithm Steps

Find the bounding rectangle coordinates (min_x, min_y, max_x, max_y)
Calculate expected total area of the bounding rectangle
Sum up areas of all input rectangles
Check if total area matches expected area
Verify no rectangles overlap by checking all pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Bounds

Calculate the outer rectangle boundaries

Sum Areas

Add up all individual rectangle areas

Check Pairs

Compare every rectangle pair for overlaps

Code -

solution.c — C

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

bool isRectangleCover(int** rectangles, int rectanglesSize, int* rectanglesColSize) {
    if (rectanglesSize == 0) return false;
    
    int minX = INT_MAX, minY = INT_MAX;
    int maxX = INT_MIN, maxY = INT_MIN;
    
    for (int i = 0; i < rectanglesSize; i++) {
        if (rectangles[i][0] < minX) minX = rectangles[i][0];
        if (rectangles[i][1] < minY) minY = rectangles[i][1];
        if (rectangles[i][2] > maxX) maxX = rectangles[i][2];
        if (rectangles[i][3] > maxY) maxY = rectangles[i][3];
    }
    
    long long expectedArea = (long long)(maxX - minX) * (maxY - minY);
    long long actualArea = 0;
    
    for (int i = 0; i < rectanglesSize; i++) {
        actualArea += (long long)(rectangles[i][2] - rectangles[i][0]) * (rectangles[i][3] - rectangles[i][1]);
    }
    
    if (actualArea != expectedArea) return false;
    
    // Check overlaps
    for (int i = 0; i < rectanglesSize; i++) {
        for (int j = i + 1; j < rectanglesSize; j++) {
            int* r1 = rectangles[i];
            int* r2 = rectangles[j];
            if (!(r1[2] <= r2[0] || r2[2] <= r1[0] || r1[3] <= r2[1] || r2[3] <= r1[1])) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We need to check every pair of rectangles for overlaps, resulting in O(n²) comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing a few variables for coordinates and areas

✓ Linear Space

Constraints

1 ≤ rectangles.length ≤ 2 × 10⁴
rectangles[i].length == 4
-10⁵ ≤ x_i, y_i, a_i, b_i ≤ 10⁵
All rectangles are axis-aligned and have positive area

28.4K 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

Brute Force Area Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler