Codestin Search App

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
✓ 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)	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) — Algorithm Steps

Generate all combinations of 4 points from the input
For each combination, extract all x and y coordinates
Check if there are exactly 2 unique x-values and 2 unique y-values
Verify that each (x,y) combination exists in the 4 points
Calculate area and keep track of the minimum
Return the minimum area found, or 0 if no rectangles exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Select 4 Points

Choose any 4 points from the input array

Extract Coordinates

Get all x and y values from the selected points

Check Uniqueness

Verify exactly 2 unique x-values and 2 unique y-values exist

Validate Rectangle

Confirm all 4 corner combinations (xi, yj) are present

Calculate Area

Compute area = |x2-x1| × |y2-y1| and track minimum

Code -

solution.c — C

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

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

int minAreaRect(int** points, int pointsSize, int* pointsColSize) {
    if (pointsSize < 4) return 0;
    
    int minArea = INT_MAX;
    
    // Check all combinations of 4 points
    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 xCoords[4] = {points[i][0], points[j][0], points[k][0], points[l][0]};
                    int yCoords[4] = {points[i][1], points[j][1], points[k][1], points[l][1]};
                    
                    // Find unique x and y coordinates
                    int uniqueX[2], uniqueY[2];
                    int xCount = 0, yCount = 0;
                    
                    // Extract unique x coordinates
                    for (int m = 0; m < 4; m++) {
                        int found = 0;
                        for (int n = 0; n < xCount; n++) {
                            if (uniqueX[n] == xCoords[m]) {
                                found = 1;
                                break;
                            }
                        }
                        if (!found && xCount < 2) {
                            uniqueX[xCount++] = xCoords[m];
                        }
                    }
                    
                    // Extract unique y coordinates
                    for (int m = 0; m < 4; m++) {
                        int found = 0;
                        for (int n = 0; n < yCount; n++) {
                            if (uniqueY[n] == yCoords[m]) {
                                found = 1;
                                break;
                            }
                        }
                        if (!found && yCount < 2) {
                            uniqueY[yCount++] = yCoords[m];
                        }
                    }
                    
                    // Check if we have exactly 2 unique x and 2 unique y coordinates
                    if (xCount == 2 && yCount == 2) {
                        // Verify all 4 corner points exist
                        int valid = 1;
                        for (int x = 0; x < 2 && valid; x++) {
                            for (int y = 0; y < 2 && valid; y++) {
                                int found = 0;
                                for (int p = 0; p < 4; p++) {
                                    if (xCoords[p] == uniqueX[x] && yCoords[p] == uniqueY[y]) {
                                        found = 1;
                                        break;
                                    }
                                }
                                if (!found) valid = 0;
                            }
                        }
                        
                        if (valid) {
                            int area = abs_val(uniqueX[1] - uniqueX[0]) * abs_val(uniqueY[1] - uniqueY[0]);
                            if (area < minArea) {
                                minArea = area;
                            }
                        }
                    }
                }
            }
        }
    }
    
    return minArea == INT_MAX ? 0 : minArea;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

We check all C(n,4) combinations of 4 points, which is O(n⁴), and for each combination we do O(1) validation work

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track the current combination and minimum area

✓ Linear 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

Brute Force (Check All 4-Point Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler