Maximum Area Rectangle With Point Constraints II

Maximum Area Rectangle With Point Constraints II - Problem

There are n points on an infinite plane. You are given two integer arrays xCoord and yCoord where (xCoord[i], yCoord[i]) represents the coordinates of the i^th point.

Your task is to find the maximum area of a rectangle that:

Can be formed using four of these points as its corners
Does not contain any other point inside or on its border
Has its edges parallel to the axes

Return the maximum area that you can obtain or -1 if no such rectangle is possible.

Input & Output

Example 1 — Valid Rectangle

$ Input: xCoord = [1,1,3,3], yCoord = [1,3,1,3]

› Output: 4

💡 Note: Four points form a 2×2 rectangle with corners at (1,1), (1,3), (3,1), (3,3). No other points inside, area = 2×2 = 4

Example 2 — Point Inside Rectangle

$ Input: xCoord = [1,1,3,3,2], yCoord = [1,3,1,3,2]

› Output: -1

💡 Note: Point (2,2) lies inside any rectangle formed by the corner points, making no valid rectangle possible

Example 3 — Multiple Valid Rectangles

$ Input: xCoord = [1,1,3,3,5,5], yCoord = [1,3,1,3,1,3]

› Output: 8

💡 Note: Two rectangles possible: (1,1)-(3,3) with area 4, and (3,1)-(5,3) with area 4. Maximum area is 4, but (1,1)-(5,3) gives area 4×2=8

Constraints

1 ≤ xCoord.length ≤ 2000
xCoord.length == yCoord.length
-10⁵ ≤ xCoord[i], yCoord[i] ≤ 10⁵
All points are unique

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 32 a Amazon 28 f Meta 22

Find the maximum area rectangle using 4 points as corners with no other points inside. The key insight is to group points by coordinates to reduce search space. The optimized approach sorts points and uses coordinate grouping for O(n³) time complexity instead of brute force O(n⁴).

Common Approaches

✓ Brute Force - Check All Combinations

⏱️ Time: O(n⁴) Space: O(1)

Iterate through all possible combinations of 4 points, check if they form a valid axis-aligned rectangle, verify no other points are inside or on the border, and track the maximum area.

Optimized - Sort and Filter

⏱️ Time: O(n³) Space: O(n)

Sort points by coordinates, group by x and y values to reduce the search space, and use more efficient containment checking with early termination.

Brute Force - Check All Combinations — Algorithm Steps

Step 1: Generate all combinations of 4 points from the given points
Step 2: For each combination, check if they form a valid rectangle
Step 3: Verify no other points lie inside or on the rectangle's border
Step 4: Calculate area and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try all C(n,4) combinations of 4 points

Validate Rectangle

Check if 4 points form axis-aligned rectangle

Check Containment

Verify no other points inside rectangle

Track Maximum

Update maximum area found so far

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

int isValidRectangle(Point* points) {
    int xs[4], ys[4];
    for (int i = 0; i < 4; i++) {
        xs[i] = points[i].x;
        ys[i] = points[i].y;
    }
    
    // Sort arrays
    for (int i = 0; i < 3; i++) {
        for (int j = i + 1; j < 4; j++) {
            if (xs[i] > xs[j]) {
                int temp = xs[i]; xs[i] = xs[j]; xs[j] = temp;
            }
            if (ys[i] > ys[j]) {
                int temp = ys[i]; ys[i] = ys[j]; ys[j] = temp;
            }
        }
    }
    
    // Check unique counts
    int uniqueXs = 1, uniqueYs = 1;
    for (int i = 1; i < 4; i++) {
        if (xs[i] != xs[i-1]) uniqueXs++;
        if (ys[i] != ys[i-1]) uniqueYs++;
    }
    
    if (uniqueXs != 2 || uniqueYs != 2) return 0;
    
    // Check if we have all 4 corners
    Point expected[4] = {{xs[0], ys[0]}, {xs[0], ys[3]}, {xs[3], ys[0]}, {xs[3], ys[3]}};
    for (int i = 0; i < 4; i++) {
        int found = 0;
        for (int j = 0; j < 4; j++) {
            if (expected[i].x == points[j].x && expected[i].y == points[j].y) {
                found = 1;
                break;
            }
        }
        if (!found) return 0;
    }
    
    return 1;
}

int noPointsInside(Point* rectPoints, Point* allPoints, int n) {
    int minX = INT_MAX, maxX = INT_MIN, minY = INT_MAX, maxY = INT_MIN;
    
    for (int i = 0; i < 4; i++) {
        if (rectPoints[i].x < minX) minX = rectPoints[i].x;
        if (rectPoints[i].x > maxX) maxX = rectPoints[i].x;
        if (rectPoints[i].y < minY) minY = rectPoints[i].y;
        if (rectPoints[i].y > maxY) maxY = rectPoints[i].y;
    }
    
    for (int i = 0; i < n; i++) {
        // Skip if point is one of the rectangle corners
        int isCorner = 0;
        for (int j = 0; j < 4; j++) {
            if (allPoints[i].x == rectPoints[j].x && allPoints[i].y == rectPoints[j].y) {
                isCorner = 1;
                break;
            }
        }
        if (isCorner) continue;
        
        // Check if point is inside or on border
        if (allPoints[i].x >= minX && allPoints[i].x <= maxX && 
            allPoints[i].y >= minY && allPoints[i].y <= maxY) {
            return 0;
        }
    }
    return 1;
}

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

int solution(int* xCoord, int* yCoord, int n) {
    if (n < 4) return -1;
    
    Point* points = malloc(n * sizeof(Point));
    for (int i = 0; i < n; i++) {
        points[i].x = xCoord[i];
        points[i].y = yCoord[i];
    }
    
    int maxArea = -1;
    
    // Try all combinations of 4 points
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                for (int l = k + 1; l < n; l++) {
                    Point rectPoints[4] = {points[i], points[j], points[k], points[l]};
                    
                    if (isValidRectangle(rectPoints)) {
                        if (noPointsInside(rectPoints, points, n)) {
                            int area = calculateArea(rectPoints);
                            if (area > maxArea) {
                                maxArea = area;
                            }
                        }
                    }
                }
            }
        }
    }
    
    free(points);
    return maxArea;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse first array
    int xCoord[1000], xCount = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        xCoord[xCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse second array
    int yCoord[1000], yCount = 0;
    token = strtok(line + 1, ",]");
    while (token) {
        yCoord[yCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(xCoord, yCoord, xCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Four nested loops to check all combinations of 4 points from n points

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for calculations

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~35 min Avg. Time

234 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 - Check All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler