【Leetcode】广度优先搜索/深度优先搜索

• 深度优先搜索 + 栈
• 广度优先搜索 + 队列

tips: 每次入栈/队列时，将数据重置

695. 岛屿的最大面积
给你一个大小为 m x n 的二进制矩阵 grid 。

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

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

 

示例 1：


输入：grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。
示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0
 

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 50
grid[i][j] 为 0 或 1

class Solution:
    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
        ans_stack = []
        c = 0
        ans = 0
        m = len(grid)
        n = len(grid[0])
        delta = [(0, -1), (0, 1), (-1, 0), (1, 0)]
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    ans_stack.append((i, j))
                    grid[i][j] = 0
                    c = 1
                    while ans_stack:
                        x, y = ans_stack.pop()
                        for p, q in delta:
                            if x + p < 0 or y + q < 0 or x + p == m or y + q == n:
                                continue
                            else:
                                if grid[x + p][y + q] == 1:
                                    ans_stack.append((x + p, y + q))
                                    grid[x + p][y + q] = 0
                                    c = c + 1
                    ans = max(ans, c)
        return ans
        

733. 图像渲染
有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

示例 1:

输入: 
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析: 
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。
注意:

image 和 image[0] 的长度在范围 [1, 50] 内。
给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。
image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535]内。

class Solution:
    def floodFill(self, image: List[List[int]], sr: int, sc: int, newColor: int) -> List[List[int]]:
        base_color = image[sr][sc]
        if base_color==newColor:
            return image
        m = len(image)
        n = len(image[0])
        res = deque()
        res.append((sr, sc))
        image[sr][sc] = newColor
        ff = [(-1, 0), (0, -1), (1, 0), (0, 1)]
        while res:
            x, y = res.popleft()
            for f in ff:
                if x + f[0] < 0 or x + f[0] >= m or y + f[1] < 0 or y + f[1] >= n:
                    continue
                elif image[x + f[0]][y + f[1]] == base_color:
                    res.append((x + f[0], y + f[1]))
                    image[x + f[0]][y + f[1]] = newColor
        return image