Battleships in a Board（统计战舰数）

Given an 2D board, count how many different 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.
（给定一个二维平面，计算在该平面上战舰的数目。用一系列’x’来表示战舰，用’.’来表示空位，规则如下：
● 给你一个由战舰或空位组成的有效平面
● 战舰只能水平或垂直放置，也就是说它们由一行N列或者N行一列组成，N可以为任何大小。
● 在俩战舰之间至少要有一个水平或垂直位置的间隔，没有相邻的。
）

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?

1.参考思路
由战舰组成的示例可以看出，构成一艘战舰的最左上角字符’x’在它位置上的左上角是没有其他’x’的，所以可以统计二维数组中所有’x’左上角相邻位置没有其他’x’的数目，该统计结果就是战舰的数目。

2.参考解法
（1）

int countBattleships(vector<vector<char>>& board) 
{
    int row = board.size();
    if(row == 0)
        return 0;
    int col = board[0].size();
    int count = 0;
    for (int i=0; i < row; ++i)
    {
        for (int j=0; j<col; ++j)
        {
            if(board[i][j] == '.') continue;                
            if(i > 0 && board[i-1][j] == 'X') continue;
            if(j > 0 && board[i][j-1] == 'X') continue;             
            ++count;
        }
    }
    return count;
}

该算法的时间复杂度为O(m*n)，空间复杂度为O(1)。

（2）洪泛填充（flood fill）

int countBattleships(vector<vector<char>>& board) {
    int ret = 0;
    for (int i = 0; i < board.size(); ++i) {
        for (int j = 0; j < board[0].size(); ++j) {
            if (board[i][j] == '.') continue;
            dfs(board, i, j);
            ++ret;
        }
    }
    return ret;
}

void dfs(vector<vector<char>> &board, int x, int y) {
    if (board[x][y] == '.') return;
    board[x][y] = '.';
    int dx[] = {1, -1, 0, 0};
    int dy[] = {0, 0, 1, -1};
    for (int i = 0; i < 4; ++i) {
        int xx = x + dx[i];
        int yy = y + dy[i];
        if (xx < 0 || xx == board.size() || yy < 0 || yy == board[0].size()) continue;
        dfs(board, xx, yy);
    }
}

该算法的时间复杂度为O(m*n)

3.总结
上面的解法一简单易懂，但实际上能想出这种巧妙的方法需要较强的观察分析能力。解法二则采用了DFS，由于涉及到递归，所以效率上远低于解法一。

PS：

• 题目的中文翻译是本人所作，如有偏差敬请指正。
• 其中的“个人分析”和“个人解法”均是本人最初的想法和做法，不一定是对的，只是作为一个对照和记录。