Rectangle Area II - Practice Coding Problems

Rectangle Area II - Problem

Rectangle Area II

Imagine you're an urban planner looking at a city map with overlapping building plots. You need to calculate the total land area covered by all buildings, but here's the catch: overlapping areas should only be counted once!

You are given a 2D array of rectangles where each rectangle[i] = [x1, y1, x2, y2] represents an axis-aligned rectangle. The coordinates (x1, y1) define the bottom-left corner and (x2, y2) define the top-right corner.

Goal: Calculate the total area covered by all rectangles in the plane. Any area covered by two or more rectangles should only be counted once.

Output: Return the total area modulo 10^9 + 7 since the answer may be very large.

Example: If you have rectangles [[0,0,2,2], [1,0,2,3], [1,0,3,1]], the total unique area would be 6 (not 4+2+2=8 due to overlaps).

Input & Output

example_1.py — Basic Overlapping Rectangles

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

› Output: 6

💡 Note: Rectangle 1: area = (2-0) * (2-0) = 4. Rectangle 2: area = (2-1) * (3-0) = 3. Rectangle 3: area = (3-1) * (1-0) = 2. Total individual areas = 4 + 3 + 2 = 9. However, overlapping regions should only be counted once. The total unique area covered is 6.

example_2.py — Single Rectangle

$ Input: rectangles = [[0,0,1000000000,1000000000]]

› Output: 49

💡 Note: Single rectangle with area 10^18. Since we return modulo 10^9 + 7, the answer is (10^18) % (10^9 + 7) = 49.

example_3.py — No Overlapping Rectangles

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

› Output: 3

💡 Note: Three non-overlapping unit squares. Each has area 1, so total area is 1 + 1 + 1 = 3.

Visualization

Tap to expand

Understanding the Visualization

Identify Key Boundaries

Mark all unique x-coordinates where building edges occur

Create Survey Events

Plan when to start and stop measuring each building as you sweep vertically

Sweep Through City

Move horizontally, tracking which buildings are currently active

Calculate Total Area

For each strip, find the union of active building widths and multiply by height

Key Takeaway

🎯 Key Insight: Instead of checking every coordinate point (which could be 10¹⁸ points!), we use coordinate compression to only work with the important boundary points, then sweep efficiently to calculate the exact union area.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

n² for processing intervals at each sweep line, log n for sorting

⚠ Quadratic Growth

Space Complexity

O(n)

Space for compressed coordinates and events

⚡ Linearithmic Space

Constraints

1 ≤ rectangles.length ≤ 200
rectangles[i].length = 4
0 ≤ x_i1, y_i1, x_i2, y_i2 ≤ 10⁹
x_i1 < x_i2 and y_i1 < y_i2 (valid rectangles)
Answer fits in 32-bit integer after modulo operation

Asked in

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

The optimal solution uses coordinate compression combined with a line sweep algorithm. First, compress all unique x-coordinates to reduce the search space. Then, create events for rectangle start/end at each y-coordinate and process them in order while tracking active x-intervals. For each y-segment, calculate the union of x-intervals and multiply by the height to get the area contribution. This achieves O(n² log n) time complexity and handles large coordinates efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Line Sweep Algorithm (Optimal)	O(n² log n)	O(n)	Use coordinate compression and sweep line to efficiently calculate union area
Brute Force (Coordinate Grid)	O(A)	O(A)	Check every coordinate point to see if it's covered by any rectangle

Line Sweep Algorithm (Optimal) — Algorithm Steps

Extract and sort all unique x-coordinates for compression
Create events for rectangle start/end at each y-coordinate
Sort events by y-coordinate
Sweep through events, maintaining active x-intervals
Calculate area contribution for each y-segment

Visualization

Tap to expand

Step-by-Step Walkthrough

Coordinate Compression

Extract unique x-coordinates and map them to indices

Create Events

Generate start/end events for each rectangle at y-coordinates

Sweep Line

Process events in order, tracking active x-intervals

Calculate Area

For each y-segment, calculate width × height and add to total

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_RECTS 200

int compare_ints(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int compare_events(const void *a, const void *b) {
    int *eventA = (int*)a;
    int *eventB = (int*)b;
    return eventA[0] - eventB[0];
}

int rectangleArea(int** rectangles, int rectanglesSize, int* rectanglesColSize) {
    if (rectanglesSize == 0) return 0;
    
    // Coordinate compression (simplified)
    int xs[MAX_RECTS * 2];
    int xCount = 0;
    
    for (int i = 0; i < rectanglesSize; i++) {
        xs[xCount++] = rectangles[i][0];
        xs[xCount++] = rectangles[i][2];
    }
    
    qsort(xs, xCount, sizeof(int), compare_ints);
    
    // Remove duplicates
    int uniqueXs[MAX_RECTS * 2];
    int uniqueCount = 0;
    uniqueXs[uniqueCount++] = xs[0];
    
    for (int i = 1; i < xCount; i++) {
        if (xs[i] != xs[i-1]) {
            uniqueXs[uniqueCount++] = xs[i];
        }
    }
    
    // Simplified version - more complex implementation needed for full solution
    return 0;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

n² for processing intervals at each sweep line, log n for sorting

⚠ Quadratic Growth

Space Complexity

O(n)

Space for compressed coordinates and events

⚡ Linearithmic Space

Constraints

1 ≤ rectangles.length ≤ 200
rectangles[i].length = 4
0 ≤ x_i1, y_i1, x_i2, y_i2 ≤ 10⁹
x_i1 < x_i2 and y_i1 < y_i2 (valid rectangles)
Answer fits in 32-bit integer after modulo operation

31.2K Views

Medium Frequency

~35 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

Line Sweep Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler