图论（leetcode热题100）

200. 岛屿数量

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

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

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

方法一：深度优先搜索

将二维网格看成一个无向图，竖直或水平相邻的 1 之间有边相连。

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

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

class Solution:  
    def numIslands(self, grid: List[List[str]]) -> int:
        def dfs(grid, r, c):
            nr = len(grid)
            nc = len(grid[0])
            grid[r][c]="0"
            for (x,y) in [(r-1,c),(r+1,c),(r,c-1),(r,c+1)]:
                if 0<= x <nr and 0<= y < nc and grid[x][y]=="1":
                    dfs(grid, x, y)
        num = 0
        if len(grid)==0:
            # print(grid)
            return num
        nr = len(grid)
        nc = len(grid[0])
        for x in range(nr):
            for y in range(nc):
                if grid[x][y]=="1":
                    # print(x,y)
                    num += 1
                    dfs(grid, x, y)
        return num

方法二：广度优先搜索

为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 111，则将其加入队列，开始进行广度优先搜索。在广度优先搜索的过程中，每个搜索到的 111 都会被重新标记为 000。直到队列为空，搜索结束。

class Solution:  
    def numIslands(self, grid: List[List[str]]) -> int:
        num = 0
        if len(grid)==0:
            # print(grid)
            return num
        nr = len(grid)
        nc = len(grid[0])
        for x in range(nr):
            for y in range(nc):
                if grid[x][y]=="1":
                    # print(x,y)
                    num += 1
                    grid[x][y]="0"
                    Q = collections.deque([(x,y)])
                    while Q:                       
                        row, col = Q.popleft()
                        grid[row][col]="0"
                        for (r,c) in [(row-1,col),(row+1,col),(row,col-1),(row,col+1)]:
                            if 0<= r <nr and 0<= c < nc and grid[r][c]=="1":
                                grid[r][c]="0"
                                Q.append((r,c))                    
        return num

994. 腐烂的橘子

观察到对于所有的腐烂橘子，其实它们在广度优先搜索上是等价于同一层的节点的。

假设这些腐烂橘子刚开始是新鲜的，而有一个腐烂橘子(我们令其为超级源点)会在下一秒把这些橘子都变腐烂，而这个腐烂橘子刚开始在的时间是 −1 ，那么按照广度优先搜索的算法，下一分钟也就是第 000 分钟的时候，这个腐烂橘子会把它们都变成腐烂橘子，然后继续向外拓展，所以其实这些腐烂橘子是同一层的节点。那么在广度优先搜索的时候，我们将这些腐烂橘子都放进队列里进行广度优先搜索即可，最后每个新鲜橘子被腐烂的最短时间 dis[x][y]其实是以这个超级源点的腐烂橘子为起点的广度优先搜索得到的结果。

为了确认是否所有新鲜橘子都被腐烂，可以记录一个变量 cnt 表示当前网格中的新鲜橘子数，广度优先搜索的时候如果有新鲜橘子被腐烂，则 cnt-=1 ，最后搜索结束时如果 cnt 大于0 ，说明有新鲜橘子没被腐烂，返回 −1，否则返回所有新鲜橘子被腐烂的时间的最大值即可，也可以在广度优先搜索的过程中把已腐烂的新鲜橘子的值由 1 改为 2，最后看网格中是否由值为 1 即新鲜的橘子即可。

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        nr, nc = len(grid), len(grid[0])
        q = collections.deque()
        for r in range(nr):
            for c in range(nc):
                if grid[r][c] == 2:
                    q.append((r, c, 0))
        def nei(x,y) -> (int, int):
            for (a, b) in ((x-1, y), (x+1, y), (x, y-1), (x, y+1)):
                if 0<= a< nr and 0<= b< nc:
                    yield a, b
        d = 0
        while q:
            x, y, d = q.popleft()
            for (a, b) in nei(x, y):
                if grid[a][b] == 1:
                    grid[a][b] = 2
                    q.append((a, b, d+1))
        if any(1 in row for row in grid):
            return -1
        else:
            return d