宽度优先搜索法

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        # 目的地在死亡数组里
        if target in deadends:
            return -1
        # 起点在死亡数字里
        if '0000' in deadends:
            return -1
        # 起点就是目标字符串
        if '0000' == target:
            return 0
        # 定义前向函数
        def prev(num):
            return str(int(num)-1) if num != '0' else '9'
        # 定义后向函数
        def after(num):
            return str(int(num)+1) if num != '9' else '0'
        # 该字符串下一个搜索集合
        def get(str_):
            # 依次对四个数字进行尝试
            arr = list(str_)
            for i in range(4):
                num = arr[i]
                # 前向查询
                arr[i] = prev(num)
                yield (''.join(arr))
                # 后向查询
                arr[i] = after(num)
                yield (''.join(arr))
                arr[i] = num
        # 初始化队列
        q = collections.deque([('0000', 0)])
        # 初始化访问数组，避免死循环
        seen = set(['0000'])
        # 广度优先搜索寻找路径
        while q:
            # 出队操作
            top = q.popleft()
            str_, step = top
            print(str_)
            for s in get(str_):
                # 判断是否为目标
                if s == target:
                    return step + 1
                # 是否在访问数组中或者死亡数组中
                if s not in seen and s not in deadends:
                    q.append((s, step + 1))
                    # 添加访问数组
                    seen.add(s)
        return -1

在这里插入图片描述

A*算法寻路

# 定义A*算法类
class AStar(object):
    def __init__(self, status, target, g):
        self.status = status
        self.g = g
        self.h = AStar.getH(status, target)
        self.f = self.g + self.h 
    @staticmethod
    def getH(status, target):
        sum_ = 0
        # 对四个字符分别求曼哈顿距离
        for i in range(4):
            dis = abs(int(status[i]) - int(target[i]))
            sum_ += min(dis, 10 - dis)
        return sum_
    # 排序
    def __lt__(self, other):
        return self.f < other.f
class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        # 起点或终点在死亡数组里
        if '0000' in deadends or target in deadends:
            return -1
        # 起点就是终点
        if '0000' == target:
            return 0
        # 获取向右拨动的字符
        def forward(c):
            return str(int(c) + 1) if c != '9' else '0'
        # 获取向左拨动的字符
        def pre(c):
            return str(int(c) - 1) if c != '0' else '9'
        # 获得孩子结点的状态
        def get(str_):
            arr = list(str_)
            for i in range(4):
                c = arr[i]
                # 右拨动
                arr[i] = forward(c)
                yield ''.join(arr)
                # 左拨动
                arr[i] = pre(c)
                yield ''.join(arr)
                arr[i] = c
        # 初始化优先队列
        q = [AStar('0000', target, 0)]
        # 初始化访问数组
        seen = {'0000'}
        # 遍历优先队列
        while q:
            # 出队操作
            top = heapq.heappop(q)
            # 获取结点属性
            g = top.g
            f = top.f
            status = top.status
            for str_ in get(status):
                if str_ == target:
                    return g + 1
                if str_ not in seen and str_ not in deadends:
                    seen.add(str_)
                    heapq.heappush(q, AStar(str_, target, g + 1))
        return -1