Find the Largest Area of Square Inside Two Rectangles

Find the Largest Area of Square Inside Two Rectangles - Problem

Imagine you're a city planner working with overlapping development zones! You have n rectangles on a 2D plane, each representing a development area with edges parallel to the x and y axes.

You're given two arrays:

bottomLeft[i] = [a_i, b_i] - the bottom-left coordinates of rectangle i
topRight[i] = [c_i, d_i] - the top-right coordinates of rectangle i

Your mission: Find the maximum area of a square that can fit inside the intersecting region of at least two rectangles. If no such intersection exists where a square can fit, return 0.

Key Challenge: The square must be entirely contained within the overlapping area of at least two rectangles, and we want the largest possible square area!

Input & Output

example_1.py — Basic Intersection

$ Input: bottomLeft = [[1,1],[2,2],[3,1]], topRight = [[3,3],[4,4],[4,4]]

› Output: 1

💡 Note: Rectangle 1: (1,1) to (3,3), Rectangle 2: (2,2) to (4,4), Rectangle 3: (3,1) to (4,4). The intersection of rectangles 1 and 2 is (2,2) to (3,3) with area 1×1=1. The largest square has area 1.

example_2.py — No Intersection

$ Input: bottomLeft = [[1,1],[2,2],[1,2]], topRight = [[2,2],[3,3],[3,3]]

› Output: 1

💡 Note: Rectangle 1: (1,1) to (2,2), Rectangle 2: (2,2) to (3,3), Rectangle 3: (1,2) to (3,3). Rectangles 2 and 3 intersect from (2,2) to (3,3), giving a 1×1 square with area 1.

example_3.py — Large Intersection

$ Input: bottomLeft = [[1,1],[3,3],[3,1]], topRight = [[5,5],[6,6],[6,4]]

› Output: 4

💡 Note: Rectangle 1: (1,1) to (5,5), Rectangle 2: (3,3) to (6,6), Rectangle 3: (3,1) to (6,4). The intersection of rectangles 1 and 3 is (3,1) to (5,4) with dimensions 2×3. The largest square has side length 2, so area = 4.

Constraints

n == bottomLeft.length == topRight.length
2 ≤ n ≤ 10³
bottomLeft[i].length == topRight[i].length == 2
1 ≤ bottomLeft[i][0] < topRight[i][0] ≤ 10⁷
1 ≤ bottomLeft[i][1] < topRight[i][1] ≤ 10⁷
Each rectangle is guaranteed to be valid (bottom-left coordinates are less than top-right)

Visualization

Tap to expand

Understanding the Visualization

Setup Rectangles

Place rectangles on 2D coordinate plane

Find Intersections

Calculate overlapping regions between rectangle pairs

Calculate Squares

For each intersection, find the largest possible square

Return Maximum

Select the intersection with the largest square area

Key Takeaway

🎯 Key Insight: The largest square in any rectangle has side length equal to min(width, height). Check all rectangle pairs to find the maximum square area in their intersections.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

This problem requires finding the largest square that fits within the intersection of at least two rectangles. The key insight is that for any intersection rectangle with width W and height H, the largest square has side length min(W, H). The brute force approach checks all pairs of rectangles in O(n²) time, while the coordinate compression approach provides a more systematic solution for complex cases.

Common Approaches

Approach	Time	Space	Notes
✓ Coordinate Compression + Sweep Line	O(n² log n)	O(n²)	Use coordinate compression and sweep line algorithm for efficient intersection finding
Brute Force (Check All Pairs)	O(n²)	O(1)	Check every pair of rectangles for intersection and find the largest square

Coordinate Compression + Sweep Line — Algorithm Steps

Extract and sort all unique x and y coordinates
Create coordinate mapping for compression
For each compressed rectangle region, count overlapping rectangles
Calculate maximum square area in regions with 2+ rectangles

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Coordinates

Collect all unique x and y coordinates from rectangles

Create Grid

Form compressed coordinate grid

Check Cells

Count rectangle coverage for each grid cell

Find Maximum

Calculate largest square in cells with 2+ coverage

Code -

solution.c — C

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

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

long long largestSquareArea(int** bottomLeft, int bottomLeftSize, int* bottomLeftColSize,
                           int** topRight, int topRightSize, int* topRightColSize) {
    int n = bottomLeftSize;
    if (n < 2) return 0;
    
    // Coordinate compression
    int coords[4 * n];
    int coordCount = 0;
    
    for (int i = 0; i < n; i++) {
        coords[coordCount++] = bottomLeft[i][0];
        coords[coordCount++] = topRight[i][0];
        coords[coordCount++] = bottomLeft[i][1];
        coords[coordCount++] = topRight[i][1];
    }
    
    qsort(coords, coordCount, sizeof(int), compare);
    
    // Remove duplicates
    int unique = 1;
    for (int i = 1; i < coordCount; i++) {
        if (coords[i] != coords[unique - 1]) {
            coords[unique++] = coords[i];
        }
    }
    
    long long maxArea = 0;
    
    // Check all possible rectangles formed by coordinate pairs
    for (int i = 0; i < unique - 1; i++) {
        for (int j = i + 1; j < unique; j++) {
            for (int k = 0; k < unique - 1; k++) {
                for (int l = k + 1; l < unique; l++) {
                    int left = coords[i], right = coords[j];
                    int bottom = coords[k], top = coords[l];
                    
                    if (left >= right || bottom >= top) continue;
                    
                    // Count rectangles containing this cell
                    int count = 0;
                    for (int m = 0; m < n; m++) {
                        if (bottomLeft[m][0] <= left && right <= topRight[m][0] &&
                            bottomLeft[m][1] <= bottom && top <= topRight[m][1]) {
                            count++;
                        }
                    }
                    
                    if (count >= 2) {
                        int width = right - left;
                        int height = top - bottom;
                        int sideLength = (width < height) ? width : height;
                        long long area = (long long)sideLength * sideLength;
                        if (area > maxArea) maxArea = area;
                    }
                }
            }
        }
    }
    
    return maxArea;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Coordinate compression takes O(n log n), then we check O(n²) grid cells

⚠ Quadratic Growth

Space Complexity

O(n²)

Need space for coordinate arrays and grid representation

⚠ Quadratic Space

12.2K Views

Medium Frequency

~25 min Avg. Time

486 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

Coordinate Compression + Sweep Line — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler