[Swift]LeetCode52. N皇后 II | N-Queens II

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return the number of distinct solutions to the n-queens puzzle.

Example:

Input: 4
Output: 2
Explanation: There are two distinct solutions to the 4-queens puzzle as shown below.
[
 [".Q..",  // Solution 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // Solution 2
  "Q...",
  "...Q",
  ".Q.."]
]

---

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

上图为 8 皇后问题的一种解法。

给定一个整数 n，返回 n 皇后不同的解决方案的数量。

示例:

输入: 4
输出: 2
解释: 4 皇后问题存在如下两个不同的解法。
[
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]

---

8ms

class Solution {
    func totalNQueens(_ n: Int) -> Int {
        if n == 0 {
            return 0
        }
        var answer = 0
        var limit = (1<<n) - 1
        dfs(h: 0, r: 0, l: 0, answer: &answer, limit: &limit)
        return answer
    }
    private func dfs(h: Int, r: Int, l: Int, answer: inout Int, limit: inout Int) {
        if h == limit {
            answer += 1
            return
        }
        var position = limit & (~(h|r|l))
        while position > 0 {
            let p = position & (-position)
            position -= p
            dfs(h: h+p, r: (r+p)<<1, l: (l+p)>>1, answer: &answer, limit: &limit)
        }
    }
}

---

20ms

class Solution {
    var placeArr : [Int]!
    var totalN : Int = 0
    func canPlace(_ row:Int , _ col:Int) -> Bool{

        var colInRow : Int = 0
        var offset : Int = 0
        for idx in 0 ..< row {
            colInRow = placeArr[idx]
           
            if colInRow == col {
                return false
            }
            offset = row - idx
            if colInRow == col - offset{
                return false
            }
            if colInRow == col + offset{
                return false
            }
        }
        return true
    }
    
    var count : Int = 0
    func place(_ row:Int) -> (){
        if row == totalN {
            count += 1
        }else{
            for col in 0..<totalN {
                if canPlace(row,col) {
                    placeArr[row] = col
                    place(row + 1)
                }
            }
        }
    }
    
    func totalNQueens(_ n: Int) -> Int {
        totalN = n
        placeArr = Array(repeating : 0 , count : totalN)
        
        place(0)
        return count
    }
}

---

28ms

class Solution {
    func totalNQueens(_ n: Int) -> Int {
        var board = [[Bool]](repeating: [Bool](repeating: false, count: n), count: n)
        var result = 0
        backtrack(&board, 0, &result)
        return result
    }
    
    private func backtrack(_ board: inout [[Bool]], _ row: Int, _ result: inout Int) {
        if row == board.count {
            result += 1
        } else {
            for col in 0..<board.count where canPlaceQueen(board, row, col) {
                board[row][col] = true
                backtrack(&board, row + 1, &result)
                board[row][col] = false
            }
        }
    }
    
    private func canPlaceQueen(_ board: [[Bool]], _ row: Int, _ col: Int) -> Bool {
        let n = board.count
        
        for i in 0..<row where board[i][col] {
            return false
        }
        
        var i = row - 1
        var j = col - 1
        while i >= 0 && j >= 0 {
            if board[i][j] {
                return false
            }
            i -= 1
            j -= 1
        }
        
        i = row - 1
        j = col + 1
        while i >= 0 && j < n {
            if board[i][j] {
                return false
            }
            i -= 1
            j += 1
        }
        
        return true
    }
}

---

32ms

class Solution {
    var placeArr : [Int]!
    var totalN : Int = 0
    func canPlace(_ row:Int , _ col:Int) -> Bool{

        var colInRow : Int = 0
        var offset : Int = 0
        for idx in 0 ..< row {
            colInRow = placeArr[idx]
           
            if colInRow == col {
                return false
            }
            offset = row - idx
            if colInRow == col - offset{
                return false
            }
            if colInRow == col + offset{
                return false
            }
        }
        return true
    }
    
    var count : Int = 0
    func place(_ row:Int) -> (){
        if row == totalN {
            count += 1
        }else{
            for col in 0..<totalN {
                if canPlace(row,col) {
                    placeArr[row] = col
                    place(row + 1)
                }
            }
        }
    }
    
    func totalNQueens(_ n: Int) -> Int {
        totalN = n
        placeArr = Array(repeating : 0 , count : totalN)
        
        place(0)
        return count
    }
}

---

44ms

class Solution {
    
    func totalNQueens(_ n: Int) -> Int {
        var result = 0
        var cols = [Int]()
        cols.reserveCapacity(n)
        queensDFS(n, &cols, &result)
        return result
    }
    
    fileprivate func queensDFS(_ n: Int, _ cols: inout [Int], _ counter: inout Int) {
        if cols.count == n {
            counter += 1
            return 
        }
        
        for colIndex in 0..<n {
            guard isValid(cols, colIndex) else {
                continue
            }
            cols.append(colIndex)
            queensDFS(n, &cols, &counter)
            cols.removeLast()
        }
    }
    
    fileprivate func isValid(_ cols: [Int], _ colIndex: Int) -> Bool {
        for rowIndex in 0..<cols.count {
            if colIndex == cols[rowIndex] {
                return false
            }
            if abs(colIndex - cols[rowIndex]) == abs(cols.count - rowIndex) {
                return false
            }
        }
        return true
    }
}