BFS

• 当前节点入队
• 访问当前节点
• 左右节点依次作为当前节点，入队并访问

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if root is None:
            return 0
        node_queue = []
        node_queue.append(root)
        depth = 1
        while len(node_queue) != 0:
            sz = len(node_queue)
            for n in range(sz):
                cur = node_queue.pop(0)
                if cur.left is None and cur.right is None:
                    return depth
                if cur.left is not None:
                    node_queue.append(cur.left)
                if cur.right is not None:
                    node_queue.append(cur.right)
            depth +=1

• 受限则跳过，不继续向下遍历
• 如果有可能重复访问，导致死循环，则加入visited数组

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        if target == "0000":
            return 0
        elif "0000" in deadends:
            return -1
        q = []
        visited = []
        q.append("0000")
        visited.append("0000")
        visited.extend(deadends)
        step = 0
        while len(q) != 0:
            sz = len(q)
            for n in range(sz):
                cur = q.pop(0)
                # 终点
                # if cur in deadends:
                #     continue
                if cur == target:
                    return step
                for m in range(4):
                    up = self.plusOne(cur,m)
                    if up not in visited:
                        q.append(up)
                        visited.append(up)
                    down = self.minusOne(cur,m)
                    if down not in visited:
                        q.append(down)
                        visited.append(down)
            step += 1
        return -1

    def plusOne(self, s, j):
        char_arr = list(s)
        char_arr[j] = str((int(char_arr[j])+1)%10)
        s_new = ""
        for ch in char_arr:
            s_new += ch
        return s_new

    
    def minusOne(self, s, j):
        char_arr = list(s)
        char_arr[j] = str((int(char_arr[j])-1)%10)
        s_new = ""
        for ch in char_arr:
            s_new += ch
        return s_new

• 如果知道终点在哪，可以使用双向BFS，减少树的生长范围

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        if target == "0000":
            return 0
        elif "0000" in deadends:
            return -1
        q1 = []
        q2 = []
        visited = []
        q1.append("0000")
        q2.append(target)
        visited.extend(deadends)
        step = 0
        while len(q1) != 0 and len(q2) != 0:
            temp = []
            sz = len(q1)
            for n in range(sz):
                cur = q1.pop(0)
                # 终点
                if cur in q2:
                    return step
                visited.append(cur)
                for m in range(4):
                    up = self.plusOne(cur,m)
                    if up not in visited:
                        temp.append(up)
                    down = self.minusOne(cur,m)
                    if down not in visited:
                        temp.append(down)
            step += 1
            q1 = q2
            q2 = temp
        return -1

    def plusOne(self, s, j):
        char_arr = list(s)
        char_arr[j] = str((int(char_arr[j])+1)%10)
        s_new = ""
        for ch in char_arr:
            s_new += ch
        return s_new

    
    def minusOne(self, s, j):
        char_arr = list(s)
        char_arr[j] = str((int(char_arr[j])-1)%10)
        s_new = ""
        for ch in char_arr:
            s_new += ch
        return s_new