[Swift]LeetCode419. 甲板上的战舰 | Battleships in a Board

原文地址：https://www.cnblogs.com/strengthen/p/10333099.html 

Given an 2D board, count how many battleships are in it. The battleships are represented with 'X's, empty slots are represented with '.'s. You may assume the following rules:

• You receive a valid board, made of only battleships or empty slots.
• Battleships can only be placed horizontally or vertically. In other words, they can only be made of the shape 1xN (1 row, N columns) or Nx1 (N rows, 1 column), where N can be of any size.
• At least one horizontal or vertical cell separates between two battleships - there are no adjacent battleships.

Example:

X..X
...X
...X

In the above board there are 2 battleships.

Invalid Example:

...X
XXXX
...X

This is an invalid board that you will not receive - as battleships will always have a cell separating between them. 

Follow up:
Could you do it in one-pass, using only O(1) extra memory and without modifying the value of the board?

---

给定一个二维的甲板， 请计算其中有多少艘战舰。 战舰用 'X'表示，空位用 '.'表示。 你需要遵守以下规则：

• 给你一个有效的甲板，仅由战舰或者空位组成。
• 战舰只能水平或者垂直放置。换句话说,战舰只能由 1xN (1 行, N 列)组成，或者 Nx1 (N 行, 1 列)组成，其中N可以是任意大小。
• 两艘战舰之间至少有一个水平或垂直的空位分隔 - 即没有相邻的战舰。

示例 :

X..X
...X
...X

在上面的甲板中有2艘战舰。

无效样例 :

...X
XXXX
...X

你不会收到这样的无效甲板 - 因为战舰之间至少会有一个空位将它们分开。

进阶:

你可以用一次扫描算法，只使用O(1)额外空间，并且不修改甲板的值来解决这个问题吗？

---

20ms

class Solution {
    func countBattleships(_ board: [[Character]]) -> Int {
        
        var battle = 0
        
        for r in 0..<board.count{
            
            for c in 0..<board[0].count{
                
                if board[r][c] == "X"{
                    var cellLeft = "."
                    var cellUp = "."
                    if c > 0 {
                        cellLeft = String(board[r][c-1])
                    }
                    if r > 0{
                        cellUp = String(board[r-1][c])
                    }
                    
                    if cellUp == "." && cellLeft == "."{
                        battle += 1
                    }
                }
                
            }
        }
        
        return battle
    }
}

---

28ms

class Solution {
    func countBattleships(_ board: [[Character]]) -> Int {
        guard !board.isEmpty && !board[0].isEmpty else {
            return 0
        }

        var board = board
        let xChar = Character("X")
        let dotChar = Character(".")
        var result = 0
        for row in 0..<board.count {
            for column in 0..<board[0].count {
                let char = board[row][column]
                if char != xChar {
                    continue
                }

                board[row][column] = dotChar
                if row < board.count - 1 && board[row + 1][column] == xChar {
                    var row2 = row + 1
                    while row2 <= board.count - 1 && board[row2][column] == xChar {
                        board[row2][column] = dotChar
                        row2 += 1
                    }
                } else if column < board[0].count - 1 && board[row][column + 1] == xChar {
                    var column2 = column + 1
                    while column2 <= board[0].count - 1 && board[row][column2] == xChar {
                        board[row][column2] = dotChar
                        column2 += 1
                    }
                }
                
                result += 1
            }
        }

        return result
    }
}

---

152ms

class Solution {
    func countBattleships(_ board: [[Character]]) -> Int {
        let row = board.count
        guard row > 0 else {
            return 0
        }
        let column = board[0].count
        var num = 0
        
        for i in 0..<row {
            for j in 0..<column {
                if board[i][j] == "X" && (i == 0 || board[i - 1][j] != "X") && (j == 0 || board[i][j - 1] != "X") {
                    num += 1
                }
            }
        }
        return num
    }
}

---

172ms

class Solution {
    func countBattleships(_ board: [[Character]]) -> Int {
        var board = board
        if board.isEmpty || board[0].isEmpty {return 0}
        var m:Int = board.count
        var n:Int = board[0].count
        var res:Int = 0
        var visited:[[Bool]] = [[Bool]](repeating:[Bool](repeating:false,count:n),count:m)
        for i in 0..<m
        {
            for j in 0..<n
            {
                if board[i][j] == "X" && !visited[i][j]
                {
                    var vertical:Int = 0
                    var horizontal:Int = 0
                    dfs(&board, &visited, &vertical, &horizontal, i, j)
                    if vertical == i || horizontal == j
                    {
                        res += 1
                    }
                }                
            }           
        }
        return res
    }
    
    func dfs(_ board:inout [[Character]],_ visited:inout[[Bool]],_ vertical:inout Int,_ horizontal:inout Int,_ i:Int,_ j:Int)
    {
        var m:Int = board.count
        var n:Int = board[0].count
        if i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || board[i][j] == "."
        {
            return
        }
        vertical |= i
        horizontal |= j
        visited[i][j] = true
        dfs(&board, &visited, &vertical, &horizontal, i - 1, j)
        dfs(&board, &visited, &vertical, &horizontal, i + 1, j)
        dfs(&board, &visited, &vertical, &horizontal, i, j - 1)
        dfs(&board, &visited, &vertical, &horizontal, i, j + 1)
    }
}