Minimum Area Rectangle II - Practice Coding Problems

Minimum Area Rectangle II - Problem

Given an array of points in the X-Y plane, find the minimum area of any rectangle that can be formed from these points.

The key challenge here is that the rectangle's sides don't need to be parallel to the X and Y axes - they can be rotated at any angle! This means we need to consider all possible rectangles, not just axis-aligned ones.

Input: An array points where points[i] = [x_i, y_i] represents a point in 2D space.

Output: The minimum area of any rectangle formed from these points, or 0 if no rectangle can be formed.

Note: Answers within 10^-5 of the actual answer will be accepted due to floating point precision.

Input & Output

example_1.py — Basic Rectangle

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

› Output: 2.0

💡 Note: These four points form a rotated square. The diagonal pairs are (1,2)↔(1,0) and (2,1)↔(0,1). Both diagonals have length √8 and intersect at center (1,1). The side length is √2, so area = (√2)² = 2.0

example_2.py — Multiple Rectangles

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

› Output: 1.0

💡 Note: Multiple rectangles can be formed from these points. The smallest one uses points [1,1], [2,1], [2,0], [1,0] forming a unit square with area 1.0. Other larger rectangles exist but have greater areas.

example_3.py — No Rectangle Possible

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

› Output: 0.0

💡 Note: Only 3 points are given, but we need exactly 4 points to form a rectangle. Since no rectangle can be formed, return 0.0.

Visualization

Tap to expand

Understanding the Visualization

Generate All Pairs

Consider every pair of points as potential rectangle diagonals

Calculate Center & Length

For each diagonal, find its midpoint and length

Group by Properties

Pairs with same center and length form rectangles

Compute Areas

Calculate area using cross product of adjacent sides

Key Takeaway

🎯 Key Insight: Rectangle diagonals are equal in length and bisect each other - this property lets us efficiently group potential rectangle corners and avoid checking all 4-point combinations.

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

We check all combinations of 4 points, which is C(n,4) = O(n^4)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ points.length ≤ 50
-50 ≤ x_i, y_i ≤ 50
All points are distinct
Answers within 10^-5 of actual answer will be accepted

Asked in

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

The optimal approach uses a two-pass hash table strategy leveraging the key geometric insight that rectangle diagonals have equal lengths and bisect each other. We hash all point pairs by their diagonal center and length, then find rectangles where multiple pairs share the same key. Time complexity is O(n²) average case with O(n²) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Combinations)	O(n⁴)	O(1)	Check every combination of 4 points to see if they form a rectangle
Two-Pass Hash Table (Diagonal Centers)	O(n³)	O(n²)	Group point pairs by their diagonal center and length, then find matching diagonals

Brute Force (Check All Combinations) — Algorithm Steps

Generate all combinations of 4 points from the input
For each combination, check if it forms a valid rectangle
Verify rectangle properties: equal opposite sides and right angles
Calculate area using cross product of adjacent sides
Keep track of the minimum area found

Visualization

Tap to expand

Step-by-Step Walkthrough

Select 4 Points

Choose any 4 points from the input

Check Rectangle

Verify if these 4 points form a valid rectangle

Calculate Area

If valid, compute the area using side lengths

Track Minimum

Keep track of the smallest area found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>

typedef struct {
    int x, y;
} Point;

long long distanceSquared(Point p1, Point p2) {
    long long dx = p1.x - p2.x;
    long long dy = p1.y - p2.y;
    return dx * dx + dy * dy;
}

int compare(const void *a, const void *b) {
    long long la = *(long long*)a;
    long long lb = *(long long*)b;
    return (la > lb) - (la < lb);
}

int isRectangle(Point p1, Point p2, Point p3, Point p4) {
    Point pts[] = {p1, p2, p3, p4};
    long long distances[6];
    int idx = 0;
    
    for (int i = 0; i < 4; i++) {
        for (int j = i + 1; j < 4; j++) {
            distances[idx++] = distanceSquared(pts[i], pts[j]);
        }
    }
    
    qsort(distances, 6, sizeof(long long), compare);
    
    return distances[0] == distances[1] && distances[1] == distances[2] && 
           distances[2] == distances[3] && distances[4] == distances[5] && 
           distances[0] > 0;
}

double minAreaFreeRect(Point* points, int n) {
    if (n < 4) return 0;
    
    double minArea = DBL_MAX;
    
    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++) {
                    if (isRectangle(points[i], points[j], points[k], points[l])) {
                        double side1 = sqrt(distanceSquared(points[i], points[j]));
                        double side2 = sqrt(distanceSquared(points[j], points[k]));
                        double area = side1 * side2;
                        if (area < minArea) {
                            minArea = area;
                        }
                    }
                }
            }
        }
    }
    
    return minArea == DBL_MAX ? 0 : minArea;
}

int main() {
    Point points[] = {{1,2}, {2,1}, {1,0}, {0,1}};
    printf("%.5f\n", minAreaFreeRect(points, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

We check all combinations of 4 points, which is C(n,4) = O(n^4)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ points.length ≤ 50
-50 ≤ x_i, y_i ≤ 50
All points are distinct
Answers within 10^-5 of actual answer will be accepted

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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 (Check All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler