[Swift]LeetCode1222. 可以攻击国王的皇后 | Queens That Can Attack the King

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

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

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

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

On an 8x8 chessboard, there can be multiple Black Queens and one White King.

Given an array of integer coordinates queens that represents the positions of the Black Queens, and a pair of coordinates king that represent the position of the White King, return the coordinates of all the queens (in any order) that can attack the King.

Example 1:

Input: queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
Output: [[0,1],[1,0],[3,3]]
Explanation: 
The queen at [0,1] can attack the king cause they're in the same row.
The queen at [1,0] can attack the king cause they're in the same column.
The queen at [3,3] can attack the king cause they're in the same diagnal.
The queen at [0,4] can't attack the king cause it's blocked by the queen at [0,1].
The queen at [4,0] can't attack the king cause it's blocked by the queen at [1,0].
The queen at [2,4] can't attack the king cause it's not in the same row/column/diagnal as the king.
Example 2:

Input: queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]
Output: [[2,2],[3,4],[4,4]]
Example 3: 

Input: queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[3,7],[0,3],[4,0],[1,2],[6,3],[5,0],[0,4],[2,2],[1,1],[6,4],[5,4],[0,0],[2,6],[4,5],[5,2],[1,4],[7,5],[2,3],[0,5],[4,2],[1,0],[2,7],[0,1],[4,6],[6,1],[0,6],[4,3],[1,7]], king = [3,4]
Output: [[2,3],[1,4],[1,6],[3,7],[4,3],[5,4],[4,5]]

Constraints:

1 <= queens.length <= 63
queens[0].length == 2
0 <= queens[i][j] < 8
king.length == 2
0 <= king[0], king[1] < 8
At most one piece is allowed in a cell.

---

在一个 8x8 的棋盘上，放置着若干「黑皇后」和一个「白国王」。

「黑皇后」在棋盘上的位置分布用整数坐标数组 queens 表示，「白国王」的坐标用数组 king 表示。

「黑皇后」的行棋规定是：横、直、斜都可以走，步数不受限制，但是，不能越子行棋。

请你返回可以直接攻击到「白国王」的所有「黑皇后」的坐标（任意顺序）。 

示例 1： 

输入：queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
输出：[[0,1],[1,0],[3,3]]
解释：
[0,1] 的皇后可以攻击到国王，因为他们在同一行上。
[1,0] 的皇后可以攻击到国王，因为他们在同一列上。
[3,3] 的皇后可以攻击到国王，因为他们在同一条对角线上。
[0,4] 的皇后无法攻击到国王，因为她被位于 [0,1] 的皇后挡住了。
[4,0] 的皇后无法攻击到国王，因为她被位于 [1,0] 的皇后挡住了。
[2,4] 的皇后无法攻击到国王，因为她和国王不在同一行/列/对角线上。
示例 2：

输入：queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]
输出：[[2,2],[3,4],[4,4]]
示例 3： 

输入：queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[3,7],[0,3],[4,0],[1,2],[6,3],[5,0],[0,4],[2,2],[1,1],[6,4],[5,4],[0,0],[2,6],[4,5],[5,2],[1,4],[7,5],[2,3],[0,5],[4,2],[1,0],[2,7],[0,1],[4,6],[6,1],[0,6],[4,3],[1,7]], king = [3,4]
输出：[[2,3],[1,4],[1,6],[3,7],[4,3],[5,4],[4,5]]

提示：

1 <= queens.length <= 63
queens[0].length == 2
0 <= queens[i][j] < 8
king.length == 2
0 <= king[0], king[1] < 8
一个棋盘格上最多只能放置一枚棋子。

---

12ms

class Solution {
    func queensAttacktheKing(_ queens: [[Int]], _ king: [Int]) -> [[Int]] {
        var m = [[Int]](repeating:[Int](repeating: 0, count:8), count:8)
        for q in queens {
            m[q[0]][q[1]] = 1
        }
        
        let dirs = [(-1,-1), (-1,0), (-1,1), (1,0), (1,1), (0,1), (1,-1), (0,-1)]
        
        var ans = [[Int]]()
        for d in dirs {
            var (i, j) = (king[0], king[1])
            repeat {
                i += d.0
                j += d.1
            } while i >= 0 && i < 8 && j >= 0 && j < 8 && m[i][j] == 0
            if i >= 0 && i < 8 && j >= 0 && j < 8 {
                ans.append([i, j])   
            }
        }
        
        return ans
    }
}

---

16ms

class Solution {
    func queensAttacktheKing(_ queens: [[Int]], _ king: [Int]) -> [[Int]] {
        let setOfQueens = Set(queens)
        
        let kingRow = king[0]
        let kingCol = king[1]
        
        var result = [[Int]]()
        
        for i in stride(from: -1, through: 1, by: 2) {
            for j in stride(from: -1, through: 1, by: 2) {
                
            }
        }
        
        // to the right
        for i in kingCol..<8 {
            if i < 7 && setOfQueens.contains([kingRow, i+1]) {
                result.append([kingRow, i+1])
                break
            }
        }
        
        // to the left
        for i in (0...kingCol).reversed() {
            if i > 0 && setOfQueens.contains([kingRow, i-1]) {
                result.append([kingRow, i-1])
                break
            }
        }
        
        // down
        for i in kingRow..<8 {
            if i < 7 && setOfQueens.contains([i+1, kingCol]) {
                result.append([i+1, kingCol])
                break
            }
        }
        
        // up
        for i in (0...kingRow).reversed() {
            if i > 0 && setOfQueens.contains([i-1, kingCol]) {
                result.append([i-1, kingCol])
                break
            }
        }
        
        var index = 1
        while (kingRow + index) < 8 && (kingCol + index) < 8 {
            if setOfQueens.contains([kingRow+index, kingCol+index]) {
                result.append([kingRow+index, kingCol+index])
                break
            }
            index += 1
        }
        
        index = 1
        while (kingRow-index) >= 0 && (kingCol-index) >= 0 {
            if setOfQueens.contains([kingRow-index, kingCol-index]) {
                result.append([kingRow-index, kingCol-index])
                break
            }
            index += 1
        }
        
        index = 1
        while (kingRow+index) < 8 && (kingCol-index) >= 0 {
            if setOfQueens.contains([kingRow+index, kingCol-index]) {
                result.append([kingRow+index, kingCol-index])
                break
            }
            index += 1
        }

        var a = kingRow-1
        var b = kingCol+1
        while a >= 0 && b < 8 {
            if setOfQueens.contains([a, b]) {
                result.append([a, b])
                break
            }
            a -= 1
            b += 1
        }
        
        return result
    }
}

---

20ms

class Solution {
    func queensAttacktheKing(_ queens: [[Int]], _ king: [Int]) -> [[Int]] {
        let directions = [(0,1),(0,-1),(1,0),(-1,0),(-1,-1),(-1,1),(1,-1),(1,1)]

        var result = [[Int]]()
        for (dx,dy) in directions {
            var (x,y) = (king[0] + dx,king[1] + dy)

            while x >= 0 && y >= 0 && x < 8 && y < 8 {
                if queens.contains([x,y]) {
                    result.append([x,y])
                    break
                }
                (x,y) = (x+dx,y+dy)
            }
        }

        return result
    }
}

---

24ms

class Solution {
    func queensAttacktheKing(_ queens: [[Int]], _ king: [Int]) -> [[Int]] {
        var posD = [[-1, 0],[1, 0],[0, 1],[0, -1],[-1, -1],[1, -1],[1, 1],[-1, 1]]
        var kx = king[0]
        var ky = king[1]
        var op = [[Int]]()
        for n in posD{
            //print("try D \(n)")
            var nx = kx
            var ny = ky
            outerLoop: for i in 0...8 {
                nx = nx + n[0]
                ny = ny + n[1]
                //print("try D \(n) \([nx, ny])")
                if queens.contains([nx, ny]) {
                    op.append([nx, ny])
                    break outerLoop
                }
            }
        }
        return op
    }
}

---

28ms

class Solution {
    func queensAttacktheKing(_ queens: [[Int]], _ king: [Int]) -> [[Int]] {
        let steps = [[-1,-1],[0,-1],[1,-1],
                     [-1, 0],       [1, 0],
                     [-1, 1],[0, 1],[1, 1]]
        var r = [[Int]]()
        var m = Set<Int>()
        for queen in queens {
            m.insert(queen[0]*10 + queen[1])
        }
        for step in steps {
            var x = king[0]
            var y = king[1]
            while true {
                x += step[0]
                y += step[1]
                if x >= 0 && x < 8 && y >= 0 && y < 8 {
                    if m.contains(x * 10 + y) {
                        r.append([x, y])
                        break
                    }
                } else {
                    break
                }
            }
        }
        return r
    }
}