4.12作业

第一题
"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:

    def level(self,root: 'Node', depth, res):
        if root == None:
            return []
        # 若当前行对应的列表不存在，加一个空列表
        if len(res) < depth:
            res.append([])
        # 将当前节点的值加入当前行的 res 中
        res[depth - 1].append(root.val)
        # 递归处理子树
        for child in root.children:
            self.level(child, depth+1, res)

    def levelOrder(self, root: 'Node') -> List[List[int]]:

        res = []
        self.level(root, 1, res)
        
        return res

第二题
class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        R, C = len(grid), len(grid[0])

        # queue - all starting cells with rotting oranges
        queue = collections.deque()
        for r, row in enumerate(grid):
            for c, val in enumerate(row):
                if val == 2:
                    queue.append((r, c, 0))

        def neighbors(r, c) -> (int, int):
            for nr, nc in ((r - 1, c), (r, c - 1), (r + 1, c), (r, c + 1)):
                if 0 <= nr < R and 0 <= nc < C:
                    yield nr, nc

        d = 0
        while queue:
            r, c, d = queue.popleft()
            for nr, nc in neighbors(r, c):
                if grid[nr][nc] == 1:
                    grid[nr][nc] = 2
                    queue.append((nr, nc, d + 1))

        if any(1 in row for row in grid):
            return -1
        return d

第三题
class Solution:
    def minMutation(self, start: str, end: str, bank: List[str]) -> int:
        def get_differance(a, b):  # 返回两个基因的不同字母数
            res = 0
            for i in range(len(a)):
                if a[i] != b[i]:
                    res += 1
            return res

        if get_differance(start, end) == 0:
            return 0

        queue = collections.deque()
        queue.append((start, 0))
        seen = set()
        seen.add(start)
        while queue:
            node, layer = queue.popleft()
            if get_differance(node, end) == 0:
                return layer
            for ele in bank:
                if get_differance(node, ele) == 1 and ele not in seen:
                    queue.append((ele, layer+1))
                    seen.add(ele)

        return -1