每日刷题--图论

```python
###200.岛屿数量
##深度优先搜索
class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        def dfs(grid,r,c):
            if not 0<=r<len(grid) or not 0<=c<len(grid[0]):return 
            if grid[r][c]!="1":return  #注意题目这里输入的是字符"0",“1”
            grid[r][c]="2"
            dfs(grid,r-1,c)
            dfs(grid,r+1,c)
            dfs(grid,r,c-1)
            dfs(grid,r,c+1)
            return 1  #是岛屿,则返回1
        res=0
        for r in range(len(grid)):
            for c in range(len(grid[0])):
                if grid[r][c]=="1":
                    res+=dfs(grid,r,c)  #累加岛屿的数量
        return res
##填海
class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        res = 0
        def dfs(grid,r,c):
            grid[r][c]="0"
            for x,y in [[0,1],[1,0],[0,-1],[-1,0]]:
                r_t = r+x
                c_t = c+y
                if 0<=r_t<len(grid) and 0<=c_t<len(grid[0]) and grid[r_t][c_t] == '1':
                    dfs(grid,r_t,c_t)
        for r in range(len(grid)):
            for c in range(len(grid[0])):
                if grid[r][c]=='1':
                    dfs(grid,r,c)
                    res+=1
        return res
```



```python
###994.腐烂的橘子
directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]   # 四个转移方向

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0])
        total_oranges = 0   # 所有橘子个数
        q = deque()   # 用于BFS的队列
        # 统计所有的橘子个数，并将初始腐烂橘子的坐标id加入队列
        for i, row in enumerate(grid):
            for j, val in enumerate(row):
                if val > 0:
                    total_oranges += 1
                    if val == 2: 
                        q.append(i * n + j)
        # 初始没有腐烂橘子，如果也没有新鲜橘子则0分钟就没有新鲜橘子，如果有新鲜橘子则新鲜橘子永远不会腐烂返回-1
        if not q: 
            return 0 if total_oranges == 0 else -1
        rot_oranges = 0     # 统计最终腐烂的橘子数
        minutes = -1       # 统计时间
        # BFS
        while q:
            minutes += 1  # 分钟累加，模拟当前minutes的腐烂转移
            size = len(q)    # 当前队列中的元素，就是第minutes腐烂的橘子个数
            rot_oranges += size     # 累加腐烂橘子数
            # 模拟第minutes腐烂的橘子的扩散
            while size > 0:
                r, c = divmod(q.popleft(), n)     # 根据坐标id还原坐标
                for dr, dc in directions:
                    nr, nc = r + dr, c + dc  # 扩散的坐标
                    # 坐标合法且为新鲜橘子，则被扩散为腐烂
                    if nr >= 0 and nr < m and nc >= 0 and nc < n and grid[nr][nc] == 1:
                        grid[nr][nc] = 2   # 将新鲜橘子标记为腐烂，避免重复处理
                        q.append(nr * n + nc)
                size -= 1

        # 如果最终腐烂的橘子数等于总橘子数，则有解；否则无解返回-1
        return minutes if total_oranges == rot_oranges else - 1

##好理解一些/
class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        # 网格的长，宽
        m, n = len(grid), len(grid[0])
        # 网格每一个坐标的访问状态
        visit = [[False] * n for y in range(m)]
        # 找出最开始时，网格中所有坏橘子的坐标
        stack = [[y,x] for y in range(m) for x in range(n) if grid[y][x]==2]
        # 坏橘子传染好橘子的四个方向，上下左右
        direction = [[-1,0], [1,0], [0,-1], [0,1]]
        # 初始时间
        minute = 0
        # 开始坏橘子传染好橘子的循环，直到没有好橘子可以被传染
        while True:
            # 初始化一个stack_next，把这一轮变坏的橘子装进里面
            stack_next = []
            # 开始对坏橘子进行审查，主要是看上下左右有没有好橘子
            while stack:
                # 拿出坏橘子的坐标点
                y, x = stack.pop()
                # 再看坏橘子上下左右的坐标对应的坐标
                for d in direction:
                    y_new, x_new = y + d[0], x + d[1]
                    # 如果坐标在网格范围内，而且坐标没有被访问过，且这个坐标确实有个好橘子
                    if -1 < y_new < m and -1 < x_new < n and not visit[y_new][x_new] and grid[y_new][x_new] == 1:
                        # 观察慰问一下这个好橘子，表示已经访问过了
                        visit[y_new][x_new] = True
                        # 告诉这个好橘子，你已被隔壁的坏橘子感染，现在你也是坏橘子了
                        grid[y_new][x_new] = 2
                        # 放进stack_next里面，集中管理，精准隔离，方便排查下一轮会变坏的橘子
                        stack_next.append([y_new, x_new])
            # 如果橘子们都检查完了发现再无其他坏橘子，终止循环，宣布疫情结束
            if not stack_next: break
            # 把这一轮感染的坏橘子放进stack里，因为我们每一轮都是从stack开始搜索的
            stack = stack_next
            # 看来橘子们还没凉透，来，给橘子们续一秒，哦不，续一分钟
            minute += 1
        
        # 经过传染，审查，隔离的循环后，如果还有好橘子幸存，返回-1宣布胜利，否则返回橘子们的存活时间
        return -1 if ['survive' for y in range(m) for x in range(n) if grid[y][x]==1] else minute
```



```python
###207.课程表
###深度优先搜索（DFS）
class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        def dfs(i, que, flags):
            if flags[i] == -1: return True##-1时，树的这个分支结束
            if flags[i] == 1: return False##1时，说明这个分支还没有结束
            flags[i] = 1
            for j in que[i]:##一环套一环，将所有深度都循环完结束，进行另一个分支
                if not dfs(j, que, flags): return False
            flags[i] = -1
            return True
        que = [[] for _ in range(numCourses)]
        flags = [0 for _ in range(numCourses)]
        for a, b in prerequisites:##记录前置项
            que[b].append(a)
        for i in range(numCourses):
            if not dfs(i, que, flags): return False
        return True
###广度优先搜索（BFS）
class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        deg = [0]*numCourses ##记录课程
        qeu = [[] for _ in range(numCourses)] ##记录前置项
        for a,b in prerequisites:
            deg[a]+=1
            qeu[b].append(a)
        cla = [i for i in range(numCourses) if deg[i]==0]
        ##BFS
        while cla:
            h = cla.pop(0)
            for i in qeu[h]:
                if deg[i] >0:
                    deg[i]-=1
                    if deg[i]<=0:
                        cla.append(i)
        for i in deg:
            if i>0:
                return False
        return True
```