LeetCode200---岛屿数量的三种解法(DFS、BFS、并查集)

---

前言

解题思路链接

  题目要求：
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围

示例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

---

一、DFS解法

1.1 DFS介绍

深度优先遍历图的方法是，从图中某顶点v出发：

• 访问顶点v；
• 依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
• 若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。
  

class Solution:
    def numIslands(self, grid):
        if not grid:
            return []
        answer = 0
        row = len(grid)
        col = len(grid[0])
        for i in range(row):
            for j in range(col):
                if grid[i][j] == '1':
                    answer += 1
                    self.dfs(grid, i, j, row, col)
        return answer

    def dfs(self, grid, x, y, row, col):
        # 递归终止条件
        if x < 0 or y < 0 or x >= row or y >= col or grid[x][y] == '0':
            return []
        else:
            grid[x][y] = '0'
        # 递归搜索上下左右
        self.dfs(grid, x + 1, y, row, col)
        self.dfs(grid, x - 1, y, row, col)
        self.dfs(grid, x, y - 1, row, col)
        self.dfs(grid, x, y + 1, row, col)

二、BFS解法

2.1 BFS介绍

  广度优先搜索较之深度优先搜索之不同在于，深度优先搜索旨在不管有多少条岔路，先一条路走到底，不成功就返回上一个路口然后就选择下一条岔路，而广度优先搜索旨在面临一个路口时，把所有的岔路口都记下来，然后选择其中一个进入，然后将它的分路情况记录下来，然后再返回来进入另外一个岔路，并重复这样的操作。

class Solution:
    def numIslands(self, grid):
        if not grid:
            return []
        answer = 0
        Queue = []
        row = len(grid)
        col = len(grid[0])
        for i in range(row):
            for j in range(col):
                if grid[i][j] == '1':
                    answer += 1
                    Queue.append((i, j))
                    grid[i][j] = '0'
                    while Queue:
                        # 当前元素
                        current = Queue.pop(0)
                        x = current[0]
                        y = current[1]
                        if x-1 >= 0 and grid[x-1][y] == '1':
                            grid[x-1][y] = '0'
                            Queue.append((x-1, y))
                        if y-1 >= 0 and grid[x][y-1] == '1':
                            grid[x][y-1] = '0'
                            Queue.append((x, y-1))
                        if x+1 < row and grid[x+1][y] == '1':
                            grid[x+1][y] = '0'
                            Queue.append((x+1, y))
                        if y + 1 < col and grid[x][y+1] == '1':
                            grid[x][y+1] = '0'
                            Queue.append((x, y+1))
        return answer

三、Union Find解法

3.1 Union Find介绍

  并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的并、查）。并：合并两个不相交集合；查：查询某个元素在那个集合内。

class Solution:
    # Union Find
    # R is the row of grid
    # C is the column of grid
    # Time Complexity: O(RC)
    # Space Complexity: O(RC)
    def numIslands(self, grid):
        if grid is None or len(grid) == 0:
            return 0
        row = len(grid)
        col = len(grid[0])
        waters = 0
        uf = UnionFind(grid)
        for i in range(0, row):
            for j in range(0, col):
                if grid[i][j] == '0':
                    waters += 1
                else:
                    directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]
                    for x, y in directions:
                        x = x + i
                        y = y + j
                        if x >= 0 and y >= 0 and x < row and y < col and grid[x][y] == '1':
                            uf.union(x * col + y, i * col + j)
        return uf.getCount() - waters
        
class UnionFind:
    def __init__(self, grid):
        row = len(grid)
        col = len(grid[0])
        self.root = [-1] * (row * col)
        self.count = row * col
        for i in range(0, row * col):
            self.root[i] = i
    def find(self, x):
        if x == self.root[x]:
            return self.root[x]
        else:
            self.root[x] = self.find(self.root[x])
            return self.root[x]
    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if rootX != rootY:
            self.root[rootX] = rootY
            self.count -= 1
    def getCount(self):
        return self.count

注意：本文参考了视频链接的思路，并查集部分本人不是很会，望多多理解

总结

使用了三种方法对《岛屿数量》一题进行了汇总，参考的别人的思路，最后的并查集部分由于刚接触，不太理解，没有自己手敲，后面需要进一步加强。