文章目录

• 1. 题目
• • 1.1 示例
  • 1.2 说明
  • 1.3 提示
  • 1.4 进阶
• 2. 解法一（深度优先搜索）
• • 2.1 分析
  • 2.2 解答
  • 2.3 复杂度

1. 题目

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

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

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

1.1 示例

• 示例 $1$：

  • 输入： grid = [["1", "1", "1", "1", "0"], ["1", "1", "0", "1", "0"], ["1", "1", "0", "0", "0"], ["0", "0", "0", "0", "0"]]
  • 输出： $1$

• 示例 $2$：

  • 输入： grid = [["1", "1", "0", "0", "0"], ["1", "1", "0", "0", "0"], ["0", "0", "1", "0", "0"], ["0", "0", "0", "1", "1"]]
  • 输出： $3$

1.2 说明

• 来源： 力扣（LeetCode）
• 链接： https://leetcode-cn.com/problems/number-of-islands

1.3 提示

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• grid[i][j] 的值为 '0' 或 '1'

1.4 进阶

• 你可以使用多种方法解答这道题目么？（深度优先搜索、广度优先搜索、并查集）

2. 解法一（深度优先搜索）

2.1 分析

为了求出岛屿的数量，我们可以扫描整个二维数组。如果一个位置为 '1' ，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 '1' 都会被重新标记为 '0' 。

最终岛屿的数量就是进行深度优先搜索的次数。

2.2 解答

from typing import List


class Solution:
    def _dfs_flood(self, grid: List[List[str]], i: int, j: int):
        if i < 0 or i > len(grid) - 1 or j < 0 or j > len(grid[0]) - 1:
            return
        if grid[i][j] == '0':
            return
        grid[i][j] = '0'
        self._dfs_flood(grid, i - 1, j)
        self._dfs_flood(grid, i + 1, j)
        self._dfs_flood(grid, i, j - 1)
        self._dfs_flood(grid, i, j + 1)

    def num_of_island(self, grid: List[List[str]]) -> int:
        row, col, num = len(grid), len(grid[0]), 0
        for i in range(row):
            for j in range(col):
                if grid[i][j] == '1':
                    num += 1
                    self._dfs_flood(grid, i, j)
        return num


def main():
    grid = [["1", "1", "0", "0", "0"],
            ["1", "1", "0", "0", "0"],
            ["0", "0", "1", "0", "0"],
            ["0", "0", "0", "1", "1"]]
    sln = Solution()
    print(sln.num_of_island(grid))


if __name__ == '__main__':
    main()

• 执行用时： 124 ms , 在所有 Python3 提交中击败了 18.97% 的用户
• 内存消耗： 23.6 MB , 在所有 Python3 提交中击败了 32.53% 的用户

2.3 复杂度

• 时间复杂度： $O(mn)$，其中 $m$ 和 $n$ 分别为行数和列数。
• 空间复杂度： $O(1)$ ，因为并没有使用占用额外空间的辅助变量，但实际上由于深度优先搜索使用了递归，会有额外的内存开销。