939. Minimum Area Rectangle

using System;
using System.Collections.Generic;
public class Solution {
    public int MinAreaRect(int[][] points) {
        var pointSet = new HashSet<string>();
        foreach (var point in points) {
            pointSet.Add($"{point[0]},{point[1]}");
        }
        
        int minArea = int.MaxValue;
        for (int i = 0; i < points.Length; i++) {
            for (int j = i + 1; j < points.Length; j++) {
                int x1 = points[i][0], y1 = points[i][1];
                int x2 = points[j][0], y2 = points[j][1];
                if (x1 != x2 && y1 != y2 && pointSet.Contains($"{x1},{y2}") && pointSet.Contains($"{x2},{y1}")) {
                    minArea = Math.Min(minArea, Math.Abs(x2 - x1) * Math.Abs(y2 - y1));
                }
            }
        }
        
        return minArea == int.MaxValue ? 0 : minArea;
    }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public int MinAreaRect(int[][] points) {
        var pointSet = new HashSet<string>();
        foreach (var point in points) {
            pointSet.push_back($"{point[0]},{point[1]}");
        }
        
        int minArea = int.MaxValue;
        for (int i = 0; i < points.size(); i++) {
            for (int j = i + 1; j < points.size(); j++) {
                int x1 = points[i][0], y1 = points[i][1];
                int x2 = points[j][0], y2 = points[j][1];
                if (x1 != x2 && y1 != y2 && pointSet.Contains($"{x1},{y2}") && pointSet.Contains($"{x2},{y1}")) {
                    minArea = min(minArea, abs(x2 - x1) * abs(y2 - y1));
                }
            }
        }
        
        return minArea == int.MaxValue ? 0 : minArea;
    }
}

import java.util.*;
import java.math.*;

// Auto-generated Java draft from the C# solution. Review API differences before LeetCode submit.
public class Solution {
    public int MinAreaRect(int[][] points) {
        var pointSet = new HashSet<String>();
        foreach (var point in points) {
            pointSet.add($"{point[0]},{point[1]}");
        }
        
        int minArea = int.MaxValue;
        for (int i = 0; i < points.length; i++) {
            for (int j = i + 1; j < points.length; j++) {
                int x1 = points[i][0], y1 = points[i][1];
                int x2 = points[j][0], y2 = points[j][1];
                if (x1 != x2 && y1 != y2 && pointSet.Contains($"{x1},{y2}") && pointSet.Contains($"{x2},{y1}")) {
                    minArea = Math.min(minArea, Math.abs(x2 - x1) * Math.abs(y2 - y1));
                }
            }
        }
        
        return minArea == int.MaxValue ? 0 : minArea;
    }
}

var minAreaRect = function(points) {
    const pointSet = new Set(points.map(p => `${p[0]},${p[1]}`));
    let minArea = Infinity;
    
    for (let i = 0; i < points.length; i++) {
        for (let j = i + 1; j < points.length; j++) {
            const [x1, y1] = points[i];
            const [x2, y2] = points[j];
            if (x1 !== x2 && y1 !== y2 && pointSet.has(`${x1},${y2}`) && pointSet.has(`${x2},${y1}`)) {
                minArea = Math.min(minArea, Math.abs(x2 - x1) * Math.abs(y2 - y1));
            }
        }
    }
    
    return minArea === Infinity ? 0 : minArea;
};

def minAreaRect(points):
    point_set = set(map(tuple, points))
    min_area = float('inf')
    
    for i in range(len(points)):
        for j in range(i + 1, len(points)):
            x1, y1 = points[i]
            x2, y2 = points[j]
            if x1 != x2 and y1 != y2 and (x1, y2) in point_set and (x2, y1) in point_set:
                min_area = min(min_area, abs(x2 - x1) * abs(y2 - y1))
    
    return 0 if min_area == float('inf') else min_area

package main

import (
    "math"
    "strconv"
)

func minAreaRect(points [][]int) int {
    pointSet := make(map[string]struct{})
    for _, point := range points {
        pointSet[strconv.Itoa(point[0])+","+strconv.Itoa(point[1])] = struct{}{}
    }
    
    minArea := math.MaxInt64
    for i := 0; i < len(points); i++ {
        for j := i + 1; j < len(points); j++ {
            x1, y1 := points[i][0], points[i][1]
            x2, y2 := points[j][0], points[j][1]
            if x1 != x2 && y1 != y2 {
                if _, ok := pointSet[strconv.Itoa(x1)+","+strconv.Itoa(y2)]; ok {
                    if _, ok := pointSet[strconv.Itoa(x2)+","+strconv.Itoa(y1)]; ok {
                        minArea = int(math.Min(float64(minArea), float64(abs(x2-x1)*abs(y2-y1))))
                    }
                }
            }
        }
    }
    
    if minArea == math.MaxInt64 {
        return 0
    }
    return minArea
}

func abs(a int) int {
    if a < 0 {
        return -a
    }
    return a
}

Algorithm

Создать множество для хранения всех точек.

Инициализировать переменную для хранения минимальной площади прямоугольника с бесконечным значением.

Пройти через все пары точек:

Если две точки могут образовать диагональ прямоугольника, то проверить, существуют ли оставшиеся две точки для замкнутого прямоугольника.

Если да, вычислить площадь прямоугольника и обновить минимальную площадь.

Если минимальная площадь остается бесконечной, вернуть 0. Иначе вернуть минимальную площадь.

😎