广度+深度：岛屿的最大面积/岛屿数量

给定一个包含了一些 0 和 1 的非空二维数组 grid 。

一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

解法就是遍历了所有数字，每经过一个会使用深度优先或者是广度优先， 注意每个数字只遍历一次，所以时间复杂度是m*n(行数乘以列数)

深度优先遍历：

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        record = {}
        direction = []
        record_list = []

        length = len(grid)
        width = len(grid[0])
        max_out = 0

        for i in range(length): # 因为不能漏过每一个
            for j in range(width):
                out = 0
                if (i, j) in record:
                    continue
                if grid[i][j] == 0:
                    continue
                if grid[i][j] == 1:
                    record_list.append([i, j])
                    record[(i, j)] = 1
                    out += 1

                while record_list:
                    m, n = record_list[-1]

                    if (m+1) < length and (m+1, n) not in record and grid[m+1][n] == 1:
                        record_list.append([m+1, n])
                        out += 1
                        record[(m+1, n)] = 1
                    elif (m-1) > -1 and (m-1, n) not in record and grid[m-1][n] == 1:
                        record_list.append([m-1, n])
                        out += 1
                        record[(m-1, n)] = 1
                    elif (n+1) < width and (m, n+1) not in record and grid[m][n+1] == 1:
                        record_list.append([m, n+1])
                        out += 1
                        record[(m, n+1)] = 1
                    elif (n-1) > -1 and (m, n-1) not in record and grid[m][n-1] == 1:
                        record_list.append([m, n-1])
                        out += 1
                        record[(m, n-1)] = 1
                    else:
                        record_list.pop()
                if out > max_out:
                    max_out = out
        return max_out

广度优先遍历

# 广度优先搜索： 列表同样不能用于set集合。
class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        queue = set()
        length = len(grid)
        width = len(grid[0])
        max_out = 0
        record = {}

        for i in range(length):
            for j in range(width):
                out = 0
                if (i, j) in record:
                    continue
                if grid[i][j] == 0:
                    continue
                if grid[i][j] == 1:
                    queue.add((i, j))
                    record[(i, j)] = 1
                    out += 1

                while queue:
                    ex_queue = queue
                    queue = set()

                    for word in ex_queue:
                        m, n = word
                        if (m+1) < length and (m+1, n) not in record and grid[m+1][n] == 1:
                            queue.add((m+1, n))
                            out += 1
                            record[(m+1, n)] = 1
                        if (m-1) > -1 and (m-1, n) not in record and grid[m-1][n] == 1:
                            queue.add((m-1, n))
                            out += 1
                            record[(m-1, n)] = 1
                        if (n+1) < width and (m, n+1) not in record and grid[m][n+1] == 1:
                            queue.add((m, n+1))
                            out += 1
                            record[(m, n+1)] = 1
                        if (n-1) > -1 and (m, n-1) not in record and grid[m][n-1] == 1:
                            queue.add((m, n-1))
                            out += 1
                            record[(m, n-1)] = 1
                    
                    if out > max_out:
                        max_out = out
        return max_out

岛屿数量

这道题犯的一个致命错误就是误以为只需要使用右下的就可以了，虽然有四个选择。但是，其实必须使用四个，因为深度有限遍历的时候，无法保证左上的比你先遍历！！！！！而我们的核心思想是，遍历到了以后就不遍历了，相当于一次性把一个整个岛屿找到。

class Solution:
    def solve(self , grid ):
        # write code here
        # 并查集--字典套字典
        self.m, self.n = len(grid), len(grid[0])
        if not self.m and not self.n:
            return 0
        check = {}
        self.count = 0
         
        def dfs(i, j):
            # 四种情况是必须的，因为DFS，不一定你的左边或者上边比你先遍历
            # 比如[[0,1,0,0,0], [1,1, 0,0,0]]
            for m, n in [(i-1, j), (i+1, j), (i, j-1), (i, j+1)]:
                if (m, n) not in check and 0 <= m < self.m and 0 <= n < self.n and grid[m][n] == "1":
                    check[m, n] = 1
                    dfs(m, n)
             
        for i in range(self.m):
            for j in range(self.n):
                if (i, j) not in check and grid[i][j] == "1":
                    self.count += 1
                    dfs(i, j)
        return self.count