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， 如果能在哈希集合中找到另一条对角线的两个点 ）
该矩形的面积是，一个可能的解。
题解 ( 改进前):
因为 Swift 中的元组没实现哈希协议，
（Python 中的元组，自带哈希），
所以要用散列集合，就要实现坐标的结构体。
我参照了一下这个 StackOverFlow 的链接， 就写出了下面的。
这么写，性能比较差，Leetcode 报超时: Time Limit Exceeded
var hashValue: Int{
return "(\(x),\(y))".hashValue
}
根据题目的限制，我改进了一下哈希的方法，就通过了
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
}
}
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 我的代码
相关代码: https://github.com/BoxDengJZ/leet_algo_101
Leetcode 的强大之处 算法题解 in Swift ( 有效的数独 , 36 ) 及其 Code Review
Leetcode 的强大之处，挺多的。
本文写的是，其强大的讨论区。
讨论区里面，有各种具有启发性的代码。
（换句话说，就是有很强的代码。看了，觉得脑洞大开，大神们把语言的语法特性发挥到了极致）
里面有各种常见语言的实现
( 这里指 Leetcode 主站的， 中文站点的同一功能弱了一点 )
进入 Leetcode 的题目，
进入讨论区，里面的讨论挺多的，这道题就有 470 个帖子。
本文推荐选择 "Most Votes",
事实就是得分高的代码，看起来爽
也可以搜索一下自己关心的，
一般是按语言来搜索。
就 Leetcode 算法题，本文认为有了 Leetcode 的讨论区，和官方题解 （有些没有，最近的题都有）
其他的资料...... ,都好像有些弱
(不喜欢英语的少年，除外)
题目描述: 36. 有效的数独
判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
上图是一个部分填充的有效的数独。
数独部分空格内已填入了数字，空白格用 '.' 表示。
示例 :
输入:
输出: true
题解 ( 改进前):
下面的解法，非常直观，
根据数独的成立条件，分三次检查数字，按行，按列，按块
（先横着来，再竖着来，最后一块一块来）
因为数独有数字的唯一性，这里使用散列集合
每一次处理，通过的情况分两种，
扫描一轮，1-9 刚刚好。或者含有 ''."， 其他的数字各不相同。
class Solution {
func isValidSudoku(_ board: [[Character]]) -> Bool {
let count = board.count
var set = Set<Character>()
for i in 0..<count{
// 横着来，按行，检查数字
set = Set(board[i])
var num = board[i].reduce(0 , {(result : Int, char : Character)
in
var cent = 0
if String(char) == "."{
cent = 1
}
return result + cent
})
// 每一次处理，通过本次循环的情况分两种，
// 扫描一轮，1-9 刚刚好。或者含有 ''."， 其他的数字各不相同。
// 这里做了一个针对处理
if num > 0 , count - num != set.count - 1{
return false
}
else if num == 0, set.count != count{
return false
}
// 竖着来，按列，检查数字
set = Set(board.reduce([Character]() , { resultArray, chars in
return resultArray + [chars[i]]
}))
num = board.reduce(0 , {(result : Int, chars : [Character])
in
var cent = 0
if String(chars[i]) == "."{
cent = 1
}
return result + cent
})
if num > 0 , count - num != set.count - 1{
return false
}
else if num == 0, set.count != count{
return false
}
// 一块一块来， 按块，检查数字
let characters = board.flatMap{
return $0
}
let fisrtMiddle = ( i/3 ) * 27 + ( i % 3 ) * 3 + 1
let secondMiddle = fisrtMiddle + 9
let thirdMiddle = fisrtMiddle + 18
// 找出每一块
let arrayThree = [characters[fisrtMiddle - 1], characters[fisrtMiddle], characters[fisrtMiddle + 1],
characters[secondMiddle - 1], characters[secondMiddle], characters[secondMiddle + 1],
characters[thirdMiddle - 1], characters[thirdMiddle], characters[thirdMiddle + 1]]
set = Set(arrayThree)
num = arrayThree.reduce(0 , {(result : Int, char : Character)
in
var cent = 0
if String(char) == "."{
cent = 1
}
return result + cent
})
if num > 0 , count - num != set.count - 1{
return false
}
else if num == 0, set.count != count{
return false
}
}
return true
}
}
Code Review ：
算法上的提高
没必要计算 "." 的个数。先处理数据，把 "." 过滤掉， 再创建散列集合。
按行，按列，按块查找重复数字，就直观了很多。不需要考虑 "." 的干扰。
命名要规范，
怎么知道 set 里面包含什么？
不清晰， 不知道 num 是什么的个数。
cent 和 arrayThree 是什么鬼?
改进代码
if String(char) == "." , 可以直接写成 if char == ".
因为 "." 是字符串的字面量，也是字符的字面量。不需要把字符转化为字符串。
改进闭包
按行，计算一次循环，不为 "." 的
var num = board[i].reduce(0 , {(result : Int, char : Character)
in
var cent = 0
if String(char) == "."{
cent = 1
}
return result + cent
})
1⃣️ 直接简写闭包，减少临时变量
var num = board[i].reduce(0 , {(result, char) in
char == "." ? result + 1 : result
})
这样处理更高效
let rowDigits = board[i].filter { $0 != "." }
if rowDigits.count != Set(rowDigits).count {
return false
}
set = Set(board.reduce([Character]() , { resultArray, chars in
return resultArray + [chars[i]]
}))
2⃣️ 科学类型转换
let column = board.map { $0[i]} // Column #i
set = Set(column)
// 找出每一块
let fisrtMiddle = ( i/3 ) * 27 + ( i % 3 ) * 3 + 1
let secondMiddle = fisrtMiddle + 9
let thirdMiddle = fisrtMiddle + 18
// 找出每一块
let arrayThree = [characters[fisrtMiddle - 1], characters[fisrtMiddle], characters[fisrtMiddle + 1],
characters[secondMiddle - 1], characters[secondMiddle], characters[secondMiddle + 1],
characters[thirdMiddle - 1], characters[thirdMiddle], characters[thirdMiddle + 1]]
3⃣️ 使用数组片段 ( slice ), 发挥高阶函数的威力
let firstRow = 3 * (i / 3)
let firstCol = 3 * (i % 3)
let block = board[firstRow..<firstRow+3].flatMap { $0[firstCol..<firstCol+3]}
最后的代码:
class Solution {
func isValidSudoku(_ board: [[Character]]) -> Bool {
for i in 0..<9 {
// 按行，检查数字
let rowDigits = board[i].filter { $0 != "." }
if rowDigits.count != Set(rowDigits).count {
return false
}
// 按列，检查数字
let colDigits = board.map { $0[i] }.filter { $0 != "." }
if colDigits.count != Set(colDigits).count {
return false
}
// 按块，检查数字
let firstRow = 3 * (i / 3)
let firstCol = 3 * (i % 3)
let blockDigits = board[firstRow..<firstRow+3].flatMap { $0[firstCol..<firstCol+3]}
.filter { $0 != "." }
if blockDigits.count != Set(blockDigits).count {
return false
}
}
return true
}
}
另一种解法, 更加的函数式，性能差一些
使用 27 的散列集合， 对应 9 次循环 X 三种方式 （ 按行， 按块，按列）
排除掉 "." , 有重复的数字，就返回错误。
两层遍历顺利完成后，返回成功。
class Solution {
func isValidSudoku(_ board: [[Character]]) -> Bool {
var rowSets = Array(repeating: Set<Character>(), count: 9)
var colSets = Array(repeating: Set<Character>(), count: 9)
var blockSets = Array(repeating: Set<Character>(), count: 9)
for (i, row) in board.enumerated() {
for (j, char) in row.enumerated() where char != "." {
if !rowSets[i].insert(char).inserted {
return false
}
if !colSets[j].insert(char).inserted {
return false
}
let block = (i / 3) + 3 * (j / 3)
if !blockSets[block].insert(char).inserted {
return false
}
}
}
return true
}
}
Leetcode 链接: valid-sudoku
感谢 Martin R 大神 code review 我的代码
相关代码:
强大的代码: Python 实现
[SDK]新浪微博请求授权显示错误页面的解决方法(error:redirect_uri_mismatch)
今天在弄新浪微博分享的时候,再次遇到这个错误,由此想到可能很多人也会遭遇这个坑,特意写下来,以便后人.
在新浪微博开放平台创建了移动移动,然后把APP ID和 AppSecret填好后,轻车熟路地去调用授权页面,哦~哦~,出错了:"访问出错了.你所访问的站点在新浪微博的认证失败,请联系****或者稍后再试.(error:redirect_uri_mismatch) 新浪微博版权所有."
好吧,是祸躲不过,登录http://open.weibo.com ,选择[管理中心]->[我的应用]->["您的应用名"]->展开左侧[应用信息]->[高级信息]->OAuth2.0 授权设置 右上角[编辑]->在框里填入回调地址即可.(前期测试应用时随便填个公司主页即可.两个地址可以相同)
