leetcode每日一题.200:岛屿数量

题目描述：

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

示例1：

输入:
11110
11010
11000
00000
输出: 1

示例2：

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

题目难度：中等

分析：

和前几天的机器人题目类似，还是用深度优先搜索（dfs）来做，遍历每一个方格，如果是陆地（“1”）那么展开深搜，碰见水（“0”）则停止，同时把搜过的地方记录即可。代码如下：

java：

class Solution {
    public int numIslands(char[][] grid) {
    	// 排除空数组情况
        if (grid == null || grid.length == 0) {
            return 0;
        }
        // m，n 分别是行，列
        int m = grid.length, n = grid[0].length;
        // 岛屿数量
        int islands = 0;
        // 遍历二维数组
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                char c = grid[i][j];
                // 如果是1就说明是陆地
                if (c == '1') {
                    islands++;
                    // 是陆地的话进行深搜
                    dfs(grid, i, j, m, n);
                }
            }
        }
        return islands;
    }

    private void dfs(char[][] grid, int i, int j, int m, int n) {
    	// 定义边界，二维数组的下标以及水（“0”），当遇到水即可停止搜索
        if (i < 0 || j < 0 || i >= m || j >= n || grid[i][j] == '0') {
            return;
        }
        // 把搜索过的地方记录
        grid[i][j] = '0';
        // 分别向上下左右4个方向搜索，这里需要注意的是上和左也必须搜索，类似“口”地形
        dfs(grid, i + 1, j, m, n);
        dfs(grid, i, j + 1, m, n);
        dfs(grid, i - 1, j, m, n);
        dfs(grid, i, j - 1, m, n);
    }
}

python：

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        if grid is None or len(grid) == 0:
            return 0
        islands, m, n = 0, len(grid), len(grid[0])
        for i in range(m):
            for j in range(n):
                c = grid[i][j]
                if c == "1":
                    islands += 1
                    self.dfs(grid, i, j, m, n)
        return islands

    def dfs(self, grid: List[List[str]], i: int, j: int, m: int, n: int) -> None:
        if i < 0 or j < 0 or i >= m or j >= n or grid[i][j] == "0":
            return
        grid[i][j] = "0"
        self.dfs(grid, i + 1, j, m, n)
        self.dfs(grid, i, j + 1, m, n)
        self.dfs(grid, i - 1, j, m, n)
        self.dfs(grid, i, j - 1, m, n)

总结：

时间复杂度为$O(MN)$。