【重点】【BFS】752.打开转盘锁

原创已于 2025-06-15 13:06:58 修改 · 383 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#BFS #打开转盘锁

于 2024-01-02 15:28:50 首次发布

labuladong的算法小抄笔记专栏收录该内容

85 篇文章

订阅专栏

文章介绍了使用广度优先搜索(BFS)和启发式A*算法解决模拟开锁问题的方法，通过递归和状态转换实现逐步解锁，如果找到目标字符串则返回步数，否则返回-1。

题目

法1：BFS

基础算法，必须掌握!!!

Python

class Solution:
    def openLock(self, deadends: List[str], target: str) -> int:
        if target == "0000":
            return 0
        if "0000" in deadends:
            return -1
        deadSet = set(deadends)
        usedSet = set(["0000"])
        deque = collections.deque()
        deque.append("0000")
        step = 0
        while len(deque) > 0:
            step += 1
            tmp_size = len(deque)
            for i in range(tmp_size):
                curNum = deque.popleft()
                nextNumList = self.nextStatus(curNum)
                for tmpNum in nextNumList:
                    if tmpNum in deadSet or tmpNum in usedSet:
                        continue
                    elif tmpNum == target:
                        return step # ok
                    deque.append(tmpNum)
                    usedSet.add(tmpNum)

        return -1
    
    def nextStatus(self, curNum):
        res = []
        num_list = list(curNum)
        for i in range(len(num_list)):
            curChar = num_list[i]
            plusChar = self.plusOne(curChar)
            num_list[i] = plusChar
            res.append(''.join(num_list))
            minusChar = self.minusOne(curChar)
            num_list[i] = minusChar
            res.append(''.join(num_list))
            num_list[i] = curChar
        return res

    def plusOne(self, digit: str):
        return '0' if digit == '9' else str(int(digit) + 1)
    
    def minusOne(self, digit: str):
        return '9' if digit == '0' else str(int(digit) - 1)

Java

class Solution {
    public int openLock(String[] deadends, String target) {
        if ("0000".equals(target)) {
            return 0;
        }
        Set<String> deadSet = new HashSet<>();
        Set<String> usedSet = new HashSet<>();
        for (String tmp : deadends) {
            if ("0000".equals(tmp)) {
                return -1;
            }
            deadSet.add(tmp);
        }
        int step = 0;
        Queue<String> queue = new LinkedList<>();
        queue.offer("0000");
        usedSet.add("0000");
        while (!queue.isEmpty()) {
            ++step;
            int size = queue.size();
            for (int i = 0; i < size; ++i) { // 类似二叉树层次遍历，每层节点数量
                String curStatus = queue.poll();
                for (String nextTmp : nextStatus(curStatus)) {
                    if (!deadSet.contains(nextTmp) && !usedSet.contains(nextTmp)) {
                        if (nextTmp.equals(target)) {
                            return step;
                        }
                        queue.offer(nextTmp);
                        usedSet.add(nextTmp);
                    }
                }
            }
        }

        return -1; //无法实现返回-1
    }

    public List<String> nextStatus(String cur) {
        List<String> res = new ArrayList<>();
        char[] array = cur.toCharArray();
        for (int i = 0; i < 4; ++i) {
            char tmp = array[i];
            char plusChar = plusOne(tmp);
            char minusChar = minusOne(tmp);
            array[i] = plusChar;
            res.add(String.valueOf(array));
            array[i] = minusChar;
            res.add(String.valueOf(array));
            array[i] = tmp; // 切记这里一定要复原!!!
        }

        return res;
    }

    public char plusOne(char c) {
        return c == '9' ? '0' : (char) (c + 1);
    }

    public char minusOne(char c) {
        return c == '0' ? '9' : (char) (c - 1);
    }
}

法2：启发式-A*算法

A*算法