Maximum Area Rectangle With Point Constraints I

Maximum Area Rectangle With Point Constraints I - Problem

Array Math Binary Indexed Tree Segment Tree Geometry Sorting Enumeration Medium

You're an architect designing a rectangular foundation on a plot of land with existing structures. Given an array points where points[i] = [x_i, y_i] represents the coordinates of structures on an infinite plane, your task is to find the maximum area rectangle that can be built such that:

🔹 The rectangle uses exactly four of these points as its corners
🔹 The rectangle contains no other points inside or on its borders
🔹 The rectangle's edges are parallel to the coordinate axes

Return the maximum area achievable, or -1 if no valid rectangle exists. This problem tests your ability to work with computational geometry, coordinate validation, and optimization.

Input & Output

example_1.py — Basic Rectangle

$ Input: points = [[1,1], [1,3], [3,1], [3,3]]

› Output: 4

💡 Note: The four points form a perfect 2×2 rectangle with no other points inside. The corners are at (1,1), (1,3), (3,1), and (3,3), giving us an area of (3-1) × (3-1) = 4.

example_2.py — Point Inside Rectangle

$ Input: points = [[1,1], [1,3], [3,1], [3,3], [2,2]]

› Output: -1

💡 Note: Although points (1,1), (1,3), (3,1), (3,3) could form a rectangle, there's a point at (2,2) inside it. Since rectangles cannot contain other points, no valid rectangle exists.

example_3.py — Multiple Valid Rectangles

$ Input: points = [[1,1], [1,3], [3,1], [3,3], [1,5], [3,5]]

› Output: 4

💡 Note: Two valid rectangles exist: (1,1)→(3,3) with area 4, and (1,3)→(3,5) with area 4. We return the maximum area, which is 4.

Visualization

Tap to expand

Understanding the Visualization

Diagonal Recognition

Two points form a valid diagonal if they have different x AND y coordinates

Corner Calculation

For diagonal (x1,y1)→(x2,y2), other corners are (x1,y2) and (x2,y1)

Existence Verification

Use hash table to quickly check if calculated corners exist in point set

Boundary Validation

Ensure no other points lie inside or on the rectangle's boundary

Key Takeaway

🎯 Key Insight: By recognizing that any rectangle is uniquely defined by its diagonal, we can reduce the problem from checking O(n⁴) combinations to O(n²) diagonal pairs, making the solution much more efficient.

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Four nested loops to check all combinations of 4 points, where n is the number of points

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables and calculations

✓ Linear Space

Constraints

1 ≤ points.length ≤ 50
points[i].length == 2
0 ≤ x_i, y_i ≤ 5 × 10⁴
All given points are unique

Asked in

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

The optimal approach uses a diagonal-based strategy with hash set lookup. Instead of checking all O(n⁴) combinations, we iterate through all pairs of points as potential diagonal corners O(n²), calculate where the other corners must be, verify they exist using hash table lookup O(1), and validate no points lie inside the rectangle O(n). This gives us O(n³) time complexity with O(n) space for the hash set.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Four Nested Loops)	O(n⁴)	O(1)	Check all possible combinations of 4 points to see if they form a valid rectangle
Optimized Brute Force (Diagonal-Based)	O(n³)	O(n)	Choose diagonal pairs first, then check if the rectangle is valid

Brute Force (Four Nested Loops) — Algorithm Steps

Generate all combinations of 4 points from the input array
For each combination, check if the 4 points form a valid axis-aligned rectangle
Verify that no other points from the array lie inside or on the rectangle's boundary
Track the maximum area found among all valid rectangles

Visualization

Tap to expand

Step-by-Step Walkthrough

Select 4 Points

Pick any 4 points from the input array using nested loops

Check Rectangle

Verify if the 4 points form a valid axis-aligned rectangle

Validate Boundaries

Ensure no other points lie inside or on the rectangle's edges

Track Maximum

Update the maximum area if this rectangle is valid and larger

Code -

solution.c — C

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

int largestRectangleArea(int** points, int pointsSize, int* pointsColSize) {
    if (pointsSize < 4) return -1;
    
    int maxArea = -1;
    
    for (int i = 0; i < pointsSize; i++) {
        for (int j = i + 1; j < pointsSize; j++) {
            for (int k = j + 1; k < pointsSize; k++) {
                for (int l = k + 1; l < pointsSize; l++) {
                    int* rectPoints[4] = {points[i], points[j], points[k], points[l]};
                    
                    if (isValidRectangle(rectPoints, points, pointsSize)) {
                        int area = calculateArea(rectPoints);
                        if (area > maxArea) {
                            maxArea = area;
                        }
                    }
                }
            }
        }
    }
    
    return maxArea;
}

int isValidRectangle(int** rectPoints, int** allPoints, int allPointsSize) {
    // Extract unique x and y coordinates
    int xCoords[4], yCoords[4];
    int xCount = 0, yCount = 0;
    
    for (int i = 0; i < 4; i++) {
        xCoords[i] = rectPoints[i][0];
        yCoords[i] = rectPoints[i][1];
    }
    
    // Simple validation logic
    // Sort coordinates to check uniqueness
    for (int i = 0; i < 3; i++) {
        for (int j = i + 1; j < 4; j++) {
            if (xCoords[i] > xCoords[j]) {
                int temp = xCoords[i];
                xCoords[i] = xCoords[j];
                xCoords[j] = temp;
            }
            if (yCoords[i] > yCoords[j]) {
                int temp = yCoords[i];
                yCoords[i] = yCoords[j];
                yCoords[j] = temp;
            }
        }
    }
    
    // Check if we have exactly 2 unique x and 2 unique y coordinates
    if (xCoords[0] != xCoords[1] && xCoords[2] != xCoords[3] && xCoords[1] != xCoords[2]) return 0;
    if (yCoords[0] != yCoords[1] && yCoords[2] != yCoords[3] && yCoords[1] != yCoords[2]) return 0;
    
    return 1;
}

int calculateArea(int** rectPoints) {
    int minX = INT_MAX, maxX = INT_MIN;
    int minY = INT_MAX, maxY = INT_MIN;
    
    for (int i = 0; i < 4; i++) {
        if (rectPoints[i][0] < minX) minX = rectPoints[i][0];
        if (rectPoints[i][0] > maxX) maxX = rectPoints[i][0];
        if (rectPoints[i][1] < minY) minY = rectPoints[i][1];
        if (rectPoints[i][1] > maxY) maxY = rectPoints[i][1];
    }
    
    return (maxX - minX) * (maxY - minY);
}

int main() {
    // Parse input and call solution
    int** points = NULL;
    int pointsSize = 0;
    int* pointsColSize = NULL;
    
    printf("%d\n", largestRectangleArea(points, pointsSize, pointsColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Four nested loops to check all combinations of 4 points, where n is the number of points

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables and calculations

✓ Linear Space

Constraints

1 ≤ points.length ≤ 50
points[i].length == 2
0 ≤ x_i, y_i ≤ 5 × 10⁴
All given points are unique

38.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 (Four Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler