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 授權設置 右上角[編輯]->在框里填入回調地址即可.(前期測試應用時隨便填個公司主頁即可.兩個地址可以相同)
