Perfect Rectangle

Perfect Rectangle - Problem

Array Hash Table Math Geometry Line Sweep Hard

Given an array rectangles where rectangles[i] = [xi, yi, ai, bi] represents an axis-aligned rectangle. The bottom-left point of the rectangle is (xi, yi) and the top-right point is (ai, bi).

Return true if all the rectangles together form an exact cover of a rectangular region, meaning:

No gaps between rectangles
No overlapping areas
The combined shape is a perfect rectangle

Input & Output

Example 1 — 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: The rectangles form a perfect 3×3 rectangle from (1,1) to (4,4) with no gaps or overlaps. Total area matches: 5 rectangles with areas 4+1+2+1+1 = 9, bounding rectangle area = 3×3 = 9.

Example 2 — Gap Exists

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

› Output: false

💡 Note: There's a gap in the coverage. The rectangles don't form a complete rectangular region - missing area between coordinates (2,1) and (3,4).

Example 3 — Single Rectangle

$ Input: rectangles = [[0,0,4,1]]

› Output: true

💡 Note: A single rectangle is always a perfect rectangle cover of itself. Area = 4×1 = 4, exactly matches bounding rectangle.

Constraints

1 ≤ rectangles.length ≤ 2 × 10⁴
rectangles[i].length == 4
-10⁵ ≤ xi, yi, ai, bi ≤ 10⁵
xi < ai and yi < bi

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is that a perfect rectangle has exactly 4 corner points appearing an odd number of times (the boundary corners), while all internal corners appear an even number of times and cancel out. Best approach uses corner point tracking with area validation. Time: O(N), Space: O(N).

Common Approaches

✓ Brute Force Point Coverage

⏱️ Time: O(W × H × N) Space: O(W × H)

For each possible coordinate point in the bounding rectangle, count how many input rectangles cover it. A perfect rectangle cover means every point is covered exactly once.

Corner Point Analysis

⏱️ Time: O(N) Space: O(N)

A perfect rectangle has exactly 4 corner points (appearing once each) and all other corner points appear an even number of times. Also verify the total area matches the bounding rectangle area.

Brute Force Point Coverage — Algorithm Steps

Find the bounding rectangle coordinates
For each point in the bounding rectangle, count coverage
Return true if all points covered exactly once

Visualization

Tap to expand

Step-by-Step Walkthrough

Grid Setup

Create grid covering bounding rectangle

Mark Coverage

For each rectangle, increment grid cells it covers

Validate

Check that every cell has count = 1

Code -

solution.c — C

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

bool solution(int** rectangles, int rectSize) {
    if (rectSize == 0) return false;
    
    // Find bounding rectangle
    int minX = rectangles[0][0], minY = rectangles[0][1];
    int maxX = rectangles[0][2], maxY = rectangles[0][3];
    
    for (int i = 0; i < rectSize; 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];
    }
    
    int width = maxX - minX;
    int height = maxY - minY;
    
    // Skip large cases in brute force
    if (width > 100 || height > 100) return false;
    
    // Create coverage grid
    int** coverage = (int**)malloc(height * sizeof(int*));
    for (int i = 0; i < height; i++) {
        coverage[i] = (int*)calloc(width, sizeof(int));
    }
    
    // Mark coverage for each rectangle
    for (int i = 0; i < rectSize; i++) {
        for (int x = rectangles[i][0] - minX; x < rectangles[i][2] - minX; x++) {
            for (int y = rectangles[i][1] - minY; y < rectangles[i][3] - minY; y++) {
                coverage[y][x]++;
            }
        }
    }
    
    // Check if all points covered exactly once
    for (int i = 0; i < height; i++) {
        for (int j = 0; j < width; j++) {
            if (coverage[i][j] != 1) {
                // Free memory
                for (int k = 0; k < height; k++) free(coverage[k]);
                free(coverage);
                return false;
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < height; i++) free(coverage[i]);
    free(coverage);
    return true;
}

int main() {
    // Simple parsing for small test cases
    int rectangles[10][4];
    int count = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse basic format like [[1,1,3,3],[3,1,4,2]]
    char* ptr = line + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            for (int i = 0; i < 4; i++) {
                rectangles[count][i] = atoi(ptr);
                while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                if (*ptr == ',') ptr++;
            }
            count++;
        }
        ptr++;
    }
    
    int* rectPtrs[10];
    for (int i = 0; i < count; i++) {
        rectPtrs[i] = rectangles[i];
    }
    
    bool result = solution(rectPtrs, count);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(W × H × N)

W×H points in bounding rectangle, each checked against N rectangles

✓ Linear Growth

Space Complexity

O(W × H)

Grid to store coverage count for each coordinate point

✓ Linear Space

89.0K Views

Medium Frequency

~35 min Avg. Time

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

Brute Force Point Coverage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler