g0901_1000.s0939_minimum_area_rectangle.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0901_1000.s0939_minimum_area_rectangle;

// #Medium #Array #Hash_Table #Math #Sorting #Geometry
// #2022_03_30_Time_63_ms_(94.31%)_Space_54.6_MB_(73.31%)

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * 939 - Minimum Area Rectangle\.
 *
 * Medium
 *
 * You are given an array of points in the **X-Y** plane `points` where points[i] = [x_i, y_i].
 *
 * Return _the minimum area of a rectangle formed from these points, with sides parallel to the X and Y axes_. If there is not any such rectangle, return `0`.
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2021/08/03/rec1.JPG)
 *
 * **Input:** points = \[\[1,1],[1,3],[3,1],[3,3],[2,2]]
 *
 * **Output:** 4
 *
 * **Example 2:**
 *
 * ![](https://assets.leetcode.com/uploads/2021/08/03/rec2.JPG)
 *
 * **Input:** points = \[\[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
 *
 * **Output:** 2
 *
 * **Constraints:**
 *
 * *   `1 <= points.length <= 500`
 * *   `points[i].length == 2`
 * *   0 <= x_i, y_i <= 4 * 10⁴
 * *   All the given points are **unique**.
**/
public class Solution {
    public int minAreaRect(int[][] points) {
        if (points.length < 4) {
            return 0;
        }
        Map> map = new HashMap<>();
        for (int[] p : points) {
            map.putIfAbsent(p[0], new HashSet<>());
            map.get(p[0]).add(p[1]);
        }
        Arrays.sort(
                points,
                (a, b) ->
                        (a[0] == b[0]) ? Integer.compare(a[1], b[1]) : Integer.compare(a[0], b[0]));

        int min = Integer.MAX_VALUE;
        for (int i = 0; i < points.length - 2; i++) {
            for (int j = i + 1; j < points.length - 1; j++) {
                int[] p1 = points[i];
                int[] p2 = points[j];
                int area = Math.abs((p1[0] - p2[0]) * (p1[1] - p2[1]));
                if (area >= min || area == 0) {
                    continue;
                }
                if (map.get(p1[0]).contains(p2[1]) && map.get(p2[0]).contains(p1[1])) {
                    min = area;
                }
            }
        }
        return min == Integer.MAX_VALUE ? 0 : min;
    }
}