Code Review Swift 算法题: 最小面积矩形  Leetcode 的动人之处

题目描述: 939. 最小面积矩形

给定在 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 <= points.length <= 500 0 <= points[i][0] <= 40000 0 <= points[i][1] <= 40000 全部的点都是不一样的。

---

官方题解: 经过对角线找点

( 这个中文站没有的，主站有英文的。

中文博客，不少的。

本文，简单大白话讲 )

直觉这么走:

对于数组中的每一对点，设想他们是一个矩形的对角线，而后就简单了。

矩形有两条对角线，若是另一条对角线上面的点，也在给定的数组里面，就找出了一个知足要求的矩形。

用散列集合确认四个点。

举个例子:

有了两个点 (1, 1) 和 (5, 5) 。看一下 (1, 5) 和 (5, 1) 有没有。

有，就找到了一个知足要求的矩形。 而后，找出全部的矩形中，面积最小的。

算法这么走:

把全部的点，放入一个哈希集合。

对于每一对点，若是哈希集合 set 中包含，相关矩形四个不一样的顶点，

（ 换句话说， 交换下 x 与 y， 若是能在哈希集合中找到另外一条对角线的两个点 ）

该矩形的面积是，一个可能的解。

---

PS : 使用散列集合，就是找起来方便。化 O(n) 为 O(1).

查找，不是经过元素遍历，是经过哈希值。

散列集合听起来... , 实际就是 Set.

使用哈希，更常见的是字典，字典能够理解为哈希表 （散列表）.

缺点就是，算哈希值的时候，有碰撞风险。

(就是集合里面，多个不一样的元素，算出来的哈希值相同。

有些尴尬。

通常是把相同哈希值的元素，放入一个数组。查找到这种状况，又是遍历了 )

---

题解 ( 改进前):

由于 Swift 中的元组没实现哈希协议，

（Python 中的元组，自带哈希）

因此要用散列集合，就要实现坐标的结构体。

我参照了一下这个 StackOverFlow 的连接， 就写出了下面的。

这么写，性能比较差，Leetcode 报超时: Time Limit Exceeded

var hashValue: Int{
            return "(\(x),\(y))".hashValue
        }
复制代码

根据题目的限制，我改进了一下哈希的 get 属性，就经过了

var hashValue: Int{
            return x * 100000 + y
        }
复制代码

（ 关于 Leetcode 用 Swift 语言答题的, 报超时另外一经验是，遍历字符串的时候，先把字符串转化为数组。

Swift 遍历数组的性能，要好一些 ）

改进前

// 为了利用散列集合，构建结构体
     struct Point: 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, _ rhs: Point) -> Bool{
            return lhs.x == rhs.x && lhs.y == rhs.y
        }
    }
    
    
    func minAreaRect(_ points: [[Int]]) -> Int {
        let newPoints = points.map({ (point: [Int]) -> Point in
            return Point(point[0], point[1])
        })
      // 先把全部有效的点找出来 ( 就是，没有重复的 )
        let pointSet = Set(newPoints)
        var minArea = Int.max
      //  而后两次循环，每一对点，都尝试搭配一次，找出每个可能的矩形
        for point in points{
            for innerPoint in points{
                if point[0] != innerPoint[0] , point[1] != innerPoint[1] , pointSet.contains(Point(point[0], innerPoint[1])) ,pointSet.contains(Point(innerPoint[0], point[1])) {
            // 找出最小的矩形
                    minArea = min(minArea, abs((innerPoint[1] - point[1] ) * (innerPoint[0] - point[0])))
                }
            }
        }
        if minArea == Int.max {
            return 0
        }
        else{
            return minArea
        }
    }
   

复制代码

结构体有些冗余，不但实现了 Hashable， 还实现了 Hashable 派生出来的 Equatable 协议

Code Review:

算法上的改进 （ 使用数学提高性能， 初中的 ）

for point in points{
            for innerPoint in points{
                   if ( // ... 判断条件 ) {
            // 找出最小的矩形
                    minArea = min(minArea, abs((innerPoint[1] - point[1] ) * (innerPoint[0] - point[0])))
                }
            }
        }
复制代码

根据解题思路，对角线的两顶点。 能够设想一顶点是左下，一顶点是右上，

（ 由于设想对角线的位置，决定了后面两个点的坐标怎么取 ）

右上的顶点 x , y 值天然比 左下的大，这样就省去了取绝对值的操做。

for lowerLeft in points {
            for upperRight in points {
                if ( // ... 判断条件 ) {
                    let area = (upperRight[0] - lowerLeft[0]) * (upperRight[1] - lowerLeft[1])
                    minArea = min(minArea, area)
                }
            }
        }
复制代码

Swift 语言上的改进，

这个题目中的 Point 结构体，赋值后，就没有再修改 （写入）。 能够改 var 为 let .

Swift 4.2 中，若是结构体全部的成员变量都遵照 Hashable协议，

编译器回自动给该结构体建立 Hashable 协议的方法。

struct Point: Hashable {
    let x: Int
    let y: Int
}
复制代码

结构体有本身默认的初始化方法，不用补充一个

改进闭包

let newPoints = points.map({ (point: [Int]) -> Point in
            return Point(point[0], point[1])
        })
     let pointSet = Set(newPoints)
复制代码

Swift 语言有类型推导特性，就不用显式声明类型了。编译器可以自动推导出参数和返回值的类型

let newPoints = points.map { point in Point(x: point[0], y: point[1]) }
 let pointSet = Set(newPoints)
复制代码

通过上一步的整理，代码比较简洁，能够进一步合并

let pointSet = Set(points.map { point in Point(x: point[0], y: point[1]) })
复制代码

改进后的代码:

struct Point: Hashable {
        let x: Int
        let y: Int
    }

    func minAreaRect(_ points: [[Int]]) -> Int {
        let pointSet = Set(points.map { point in Point(x: point[0], y: point[1]) })
        var minArea = Int.max
        for lowerLeft in points {
            for upperRight in points {
                if upperRight[0] > lowerLeft[0]
                    && upperRight[1] > lowerLeft[1]
                    && pointSet.contains(Point(x: lowerLeft[0], y: upperRight[1]))
                    && pointSet.contains(Point(x: upperRight[0], y: lowerLeft[1])) {

                    let area = (upperRight[0] - lowerLeft[0]) * (upperRight[1] - lowerLeft[1])
                    minArea = min(minArea, area)
                }
            }
        }

        return minArea == Int.max ? 0 : minArea
    }

复制代码

---

Leetcode 的动人之处挺多的，本文继续 8 看代码的姿式

查看竞赛回顾

( Leetcode 的竞赛很强大，每一个星期天都有 )

进入竞赛，

下滑到竞赛回顾，点击感兴趣的一场 （就是找到想作的题目）

下滑，选择更多

点击感兴趣的题目

看到代码。 （ 代码这么多，确定看不完 ）

有了 Leetcode 讨论区，为何还推荐这样看代码？ （ 虽然是很强的人，写的代码 ）

由于这是竞赛的时候写的代码，很赶时间。 哪里有后面的那么多的设计。

很不优雅，糙，快，直观。（ 大神的代码思路，较容易的理解 ... ）

题目作不出来，能够了解一下。

（ 想看高手的，能够...

没 dollar 买会员，想作题, 例如第 772 ，靠百度。这里能够看代码思路， 第 69 场周赛 ）

Leetcode 的精华，是测试用例

测试用例多，有时候各类想不到，让程序员的思惟更加周全

例如这道题，有用例 130

这个用例，体会到了我代码的脆弱

if point[0] != innerPoint[0] , point[1] != innerPoint[1] , pointSet.contains(Point(innerPoint[0], point[1])) ,pointSet.contains(Point(innerPoint[1], point[0])) {
            // 找出最小的矩形
                    minArea = min(minArea, abs((innerPoint[1] - point[1] ) * (innerPoint[0] - point[0])))
                }
复制代码

另外一对顶点的语义，取反了

---

Leetcode 连接: Minimum Area Rectangle

感谢 Martin R code review 个人代码

相关代码: github.com/BoxDengJZ/l…