leetcode刷题记录：bfs

https://labuladong.online/algo/essential-technique/bfs-framework/

bfs的解题框架

bfs的问题，就是一幅图，从起点走到终点，问最短路径

from typing import List, Set
from collections import deque
class Node:
    def __init__(self, val: int):
        self.val = val
        self.neighbors = []

def BFS(start: Node, target: Node) -> int:
    q = deque() # 核心数据结构
    visited = set() # 避免走回头路
    q.append(start) # 将起点加入队列
    visited.add(start)

    step = 0 # 记录扩散的步数

    while q:
        step += 1
        size = len(q)
        # 将当前队列中的所有节点向四周扩散
        for i in range(size):
            cur = q.popleft()
            # 划重点：这里判断是否到达终点
            if cur == target:
                return step
            # 将cur相邻节点加入队列
            for x in cur.neighbors:
                if x not in visited:
                    q.append(x)
                    visited.add(x)
    # 如果走到这里，说明在图中没有找到目标节点
    return -1

二叉树的最小高度

https://leetcode.cn/problems/minimum-depth-of-binary-tree/

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        q = [root]
        res = []
        depth = 1
        while(q):
            sz = len(q)
            track = []
            for i in range(sz):
                temp = q.pop(0)   
                if not temp.left and not temp.right:
                    return depth             
                if temp.left:
                    q.append(temp.left)
                if temp.right:
                    q.append(temp.right)
                track.append(temp.val)
            res.append(track[:])
            depth += 1
        return len(res)

打开转盘锁

https://leetcode.cn/problems/open-the-lock/submissions/519985662/

class Solution(object):
    def openLock(self, deadends, target):
        """
        :type deadends: List[str]
        :type target: str
        :rtype: int
        """
        def plusOne(lock, i):
            if lock[i] == "9":
                new_lock = lock[:i] + "0" + lock[i+1:]
            else:
                new_lock = lock[:i] + str(int(lock[i]) + 1) + lock[i+1:]
            return new_lock
        def minusOne(lock, i):
            if lock[i] == "0":
                new_lock = lock[:i] + "9" + lock[i+1:]
            else:
                new_lock = lock[:i] + str(int(lock[i]) - 1) + lock[i+1:]
            return new_lock
        q = ["0000"]
        dead = set(deadends)
        used.add("0000")
        res = 0
        while q:
            sz = len(q)
            for i in range(sz):
                cur = q.pop(0)
                if cur in deadends:
                    continue
                if cur == target:
                    return res
                for j in range(len(target)):
                    temp = plusOne(cur, j)
                    if temp not in used and temp not in deadends:
                        q.append(temp)
                        used.add(temp)
                    temp = minusOne(cur, j)
                    if temp not in used and temp not in deadends:
                        q.append(temp)
                        used.add(temp)    
            res += 1             
        return -1