Minimum Area Rectangle - Practice Coding Problems

Minimum Area Rectangle - Problem

Imagine you're a city planner looking at a map with building locations marked as points. Your task is to find the smallest rectangular plot of land that can be formed by connecting four of these points, where the rectangle's sides must be parallel to the X and Y axes (no diagonal rectangles allowed!).

Given an array points where points[i] = [xi, yi] represents coordinates on a 2D plane, return the minimum area of any axis-aligned rectangle that can be formed using exactly 4 points from the array. If no such rectangle exists, return 0.

Key insight: A valid rectangle needs exactly 4 points forming two pairs of coordinates - if points (x1,y1), (x1,y2), (x2,y1), and (x2,y2) all exist, they form a rectangle with area |x2-x1| × |y2-y1|.

Input & Output

example_1.py — Basic Rectangle

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

› Output: 4

💡 Note: These 4 points form a perfect rectangle with corners at (1,1), (1,3), (3,1), and (3,3). The width is |3-1| = 2 and height is |3-1| = 2, giving area = 2 × 2 = 4.

example_2.py — Multiple Rectangles

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

› Output: 4

💡 Note: Even with the extra point (2,2), the minimum rectangle is still formed by the same 4 corner points, giving area 4. The point (2,2) doesn't participate in forming any smaller rectangles.

example_3.py — No Rectangle Possible

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

› Output: 0

💡 Note: With only 3 points, it's impossible to form a rectangle (which requires exactly 4 points). Even if we had 4+ points, they would need to form two pairs of coordinates to make a valid axis-aligned rectangle.

Constraints

1 ≤ points.length ≤ 500
points[i].length == 2
0 ≤ x_i, y_i ≤ 4 × 10⁴
All points are unique
Rectangle sides must be parallel to X and Y axes

Visualization

Tap to expand

Understanding the Visualization

Identify Diagonal Strategy

Any rectangle is uniquely determined by its diagonal corners

Store Points Efficiently

Use hash set for instant point existence checking

Test Diagonal Pairs

For each pair, calculate where other corners must be

Validate & Calculate

Check if calculated corners exist, compute area

Track Minimum

Keep track of the smallest area found

Key Takeaway

🎯 Key Insight: Instead of checking all 4-point combinations (O(n⁴)), focus on diagonal pairs - if two points can be diagonal corners, the other two positions are mathematically determined and can be verified in O(1) time using a hash set!

Asked in

G Google 47 a Amazon 34 ⊞ Microsoft 28 f Meta 22

The optimal approach uses a two-pass hash table strategy: first store all points for O(1) lookup, then examine each pair of points as potential diagonal corners. For each diagonal pair with different x and y coordinates, verify that the other two calculated corner points exist in the hash set. This reduces complexity from O(n⁴) brute force to O(n²) time with O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Diagonal Approach)	O(n²)	O(n)	First store all points in hash set, then check each diagonal pair for valid rectangles
Brute Force (Check All 4-Point Combinations)	O(n⁴)	O(1)	Try every possible combination of 4 points to see if they form a rectangle

Two-Pass Hash Table (Diagonal Approach) — Algorithm Steps

Store all points in a hash set for fast lookup
Iterate through all pairs of points as potential diagonal corners
For each diagonal pair, ensure they don't share x or y coordinates (not on same line)
Calculate the positions of the other two corner points
Check if both calculated corner points exist in our hash set
If valid rectangle found, calculate area and track minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Store all points in hash set for O(1) lookup

Pick Diagonal Pair

Select two points that could be diagonal corners

Validate Diagonal

Ensure points have different x AND y coordinates

Find Other Corners

Calculate positions of remaining two corners

Check Existence

Verify both calculated corners exist in hash set

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    char key[20];
    struct HashNode* next;
} HashNode;

int hash(char* key) {
    int h = 0;
    for (int i = 0; key[i]; i++) {
        h = (h * 31 + key[i]) % HASH_SIZE;
    }
    return h;
}

void insert(HashNode** table, char* key) {
    int h = hash(key);
    HashNode* node = malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->next = table[h];
    table[h] = node;
}

int contains(HashNode** table, char* key) {
    int h = hash(key);
    HashNode* node = table[h];
    while (node) {
        if (strcmp(node->key, key) == 0) return 1;
        node = node->next;
    }
    return 0;
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int minAreaRect(int** points, int pointsSize, int* pointsColSize) {
    if (pointsSize < 4) return 0;
    
    // First pass: store all points in hash table
    HashNode* pointSet[HASH_SIZE] = {NULL};
    
    for (int i = 0; i < pointsSize; i++) {
        char key[20];
        sprintf(key, "%d,%d", points[i][0], points[i][1]);
        insert(pointSet, key);
    }
    
    int minArea = INT_MAX;
    
    // Second pass: check all pairs as potential diagonal corners
    for (int i = 0; i < pointsSize; i++) {
        for (int j = i + 1; j < pointsSize; j++) {
            int x1 = points[i][0], y1 = points[i][1];
            int x2 = points[j][0], y2 = points[j][1];
            
            // Skip if points are on the same line
            if (x1 == x2 || y1 == y2) continue;
            
            // Check if the other two corners exist
            char corner1[20], corner2[20];
            sprintf(corner1, "%d,%d", x1, y2);
            sprintf(corner2, "%d,%d", x2, y1);
            
            if (contains(pointSet, corner1) && contains(pointSet, corner2)) {
                int area = abs_val(x2 - x1) * abs_val(y2 - y1);
                if (area < minArea) {
                    minArea = area;
                }
            }
        }
    }
    
    // Free hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = pointSet[i];
        while (node) {
            HashNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
    
    return minArea == INT_MAX ? 0 : minArea;
}

int main() {
    int points[][2] = {{1,1}, {1,3}, {3,1}, {3,3}, {2,2}};
    int* pointPtrs[5];
    int colSizes[5] = {2,2,2,2,2};
    
    for (int i = 0; i < 5; i++) {
        pointPtrs[i] = points[i];
    }
    
    printf("%d\n", minAreaRect(pointPtrs, 5, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all pairs of points (n²/2 pairs), and for each pair we do O(1) hash lookups

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores all n points, each taking constant space

⚡ Linearithmic Space

67.2K Views

High Frequency

~18 min Avg. Time

1.8K 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

Two-Pass Hash Table (Diagonal Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler