[Swift]LeetCode939. 最小面积矩形 | Minimum Area Rectangle

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9942063.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a set of points in the xy-plane, determine the minimum area of a rectangle formed from these points, with sides parallel to the x and y axes.

If there isn't any rectangle, return 0.

Example 1:

Input: [[1,1],[1,3],[3,1],[3,3],[2,2]]
Output: 4

Example 2:

Input: [[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
Output: 2

Note:

1. 1 <= points.length <= 500
2. 0 <= points[i][0] <= 40000
3. 0 <= points[i][1] <= 40000
4. All points are distinct.

---

给定在 xy 平面上的一组点，确定由这些点组成的矩形的最小面积，其中矩形的边平行于 x 轴和 y 轴。

如果没有任何矩形，就返回 0。

示例 1：

输入：[[1,1],[1,3],[3,1],[3,3],[2,2]]
输出：4

示例 2：

输入：[[1,1],[1,3],[3,1],[3,3],[4,1],[4,3]]
输出：2

提示：

1. 1 <= points.length <= 500
2. 0 <= points[i][0] <= 40000
3. 0 <= points[i][1] <= 40000
4. 所有的点都是不同的。

---

1672ms

class Solution {
    func minAreaRect(_ points: [[Int]]) -> Int {
        var xAxeDict: [Int:Set<Int>] = [:]
        var yAxeDict: [Int:Set<Int>] = [:]
        var pointsCoords: Set<String> =  []
        for (ind, point) in points.enumerated() {
            if var set = xAxeDict[point[0]] {
                set.insert(ind)
                xAxeDict[point[0]] = set
            } else {
                xAxeDict[point[0]] = Set([ind])
            }
            
            if var set = yAxeDict[point[1]] {
                set.insert(ind)
                yAxeDict[point[1]] = set
            } else {
                yAxeDict[point[1]] = Set([ind])
            }
        }
        
        var pointsToConsider: Set<Int> = []
        for (key, value) in xAxeDict {
            if value.count < 2 {
                continue
            }
            
            for pointInd in value {
                if yAxeDict[points[pointInd][1]]!.count > 1 {
                    pointsToConsider.insert(pointInd)
                    pointsCoords.insert("(points[pointInd][0])_(points[pointInd][1])")
                }
            }
        }
        
        var pointsArr = Array(pointsToConsider)
        pointsArr.sort()
        
        var result: Int? = nil
        
        for pointInd in pointsArr {
            let x1 = points[pointInd][0]
            let y1 = points[pointInd][1]
            let xPeers = xAxeDict[x1]!
            let yPeers = yAxeDict[y1]!
            
            for xPeer in xPeers {
                if xPeer <= pointInd {
                    continue
                }
                let y2 = points[xPeer][1]
                for yPeer in yPeers {
                    if yPeer <= pointInd {
                        continue
                    }
                    let x2 = points[yPeer][0]
                    if pointsCoords.contains("(x2)_(y2)") {
                        result = min(abs((x2 - x1) * (y2 - y1)), result ?? Int.max)
                    }
                }
            }
            
        }
        
        return result ?? 0
    }
}

---

2100ms

class Solution {
    func minAreaRect(_ points: [[Int]]) -> Int {
        var xDict: [Int: Set<Int>] = [:], yDict: [Int: Set<Int>] = [:]
        
        for array in points {
            let x = array[0], y = array[1]
            if xDict[x] == nil {
                xDict[x] = Set<Int>()
            }
            xDict[x]!.insert(y)

            if yDict[y] == nil {
                yDict[y] = Set<Int>()
            }
            yDict[y]!.insert(x)
        }
        
        var res = Int.max
        for (x, setY) in xDict {
            var i = 0, j = 1, arrayY = Array(setY)
            for i in 0..<arrayY.count {
                for j in 1..<arrayY.count {
                    if arrayY[i] == arrayY[j] { continue }
                    if let set = yDict[arrayY[i]] {
                        for item in set {
                            if item == x { continue }
                            if let setX = yDict[arrayY[j]], setX.contains(item) {
                                res = min(res, abs(arrayY[j] - arrayY[i]) * abs(item - x))
                            }
                        }
                    }
                }
            }
        }
 
        return res == Int.max ? 0 : res
    }
}

---

2296ms

class Solution {
        struct Point:Hashable{
            var x:Int;
            var y:Int;
        }
        func minAreaRect(_ points: [[Int]]) -> Int {
            var minArea = Int.max;
            let pointSet = points.map{
                (onePoint:[Int]) -> Point in
                return Point(x:onePoint[0],y:onePoint[1])
            }
            let set = Set<Point>(pointSet);
            for lowerLeft in pointSet{
                for upperRight in pointSet{
                    if lowerLeft.x < upperRight.x && lowerLeft.y < upperRight.y && set.contains(Point(x: lowerLeft.x, y: upperRight.y)) && set.contains(Point(x:upperRight.x,y: lowerLeft.y)){
                        let area = (upperRight.x - lowerLeft.x)*(upperRight.y - lowerLeft.y)
                        if (area < minArea) {
                            minArea = area;
                        }
                    }
                }
            }
            return minArea == Int.max ? 0 : minArea;
        }
    }

---

2432ms

class Solution {
    func minAreaRect(_ points: [[Int]]) -> Int {
        var n:Int = points.count
        var set:Set<Int64> = Set<Int64>()
        for i in 0..<n
        {
            set.insert(Int64(points[i][0]<<32|points[i][1]))
        }
        
        var ret:Int = Int.max
        for i in 0..<n
        {
            for j in (i + 1)..<n
            {
                let S:Int64 = abs(Int64((points[i][0]-points[j][0])*(points[i][1]-points[j][1])))
                if S == 0 {continue}
                var x:Int64 = Int64(points[i][0]<<32|points[j][1])
                if !set.contains(x) {continue}
                x = Int64(points[j][0]<<32|points[i][1])
                if !set.contains(x) {continue}
                ret = min(ret, Int(S))
            }
        }
        if ret == Int.max {return 0}
        return ret
    }
}

---

2924ms

class Solution {
    struct Point_Dng: Hashable{
        var x: Int
        var y: Int
        
        init(_ x: Int, _ y: Int) {
            self.x = x
            self.y = y
        }
        
        var hashValue: Int{
            return x * 100000 + y
        }
        
        
        static func == (_ lhs: Point_Dng, _ rhs: Point_Dng) -> Bool{
            return lhs.x == rhs.x && lhs.y == rhs.y
        }
    }
    
    func minAreaRect(_ points: [[Int]]) -> Int {
        let points_new = points.map({ (point: [Int]) -> Point_Dng in
            return Point_Dng(point[0], point[1])
        })
        let set = Set(points_new)
        var ans = Int.max
        for point in points{
            
            for point_piece in points{
                
                
                if point[0] != point_piece[0] , point[1] != point_piece[1] , set.contains(Point_Dng(point[0], point_piece[1])) ,set.contains(Point_Dng(point_piece[0], point[1])) {
                    
                    ans = min(ans, abs((point_piece[1] - point[1] ) * (point_piece[0] - point[0])))
                }

            }
        }
        
        if ans == Int.max {
            return 0
        }
        else{
            return ans
        }

    }
}