【LeetCode】第752题——打开转盘锁（难度：中等）

题目描述

你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。

锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。

列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。

字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -1 。

1. 示例 1:
   输入：deadends = [“0201”,“0101”,“0102”,“1212”,“2002”], target = “0202”
   输出：6
   解释：
   可能的移动序列为 “0000” -> “1000” -> “1100” -> “1200” -> “1201” -> “1202” -> “0202”。
   注意 “0000” -> “0001” -> “0002” -> “0102” -> “0202” 这样的序列是不能解锁的，
   因为当拨动到 “0102” 时这个锁就会被锁定。

2. 示例 2:
   输入: deadends = [“8888”], target = “0009”
   输出：1
   解释：
   把最后一位反向旋转一次即可 “0000” -> “0009”。

3. 示例 3:
   输入: deadends = [“8887”,“8889”,“8878”,“8898”,“8788”,“8988”,“7888”,“9888”], target = “8888”
   输出：-1
   解释：
   无法旋转到目标数字且不被锁定。

4. 示例 4:
   输入: deadends = [“0000”], target = “8888”
   输出：-1

提示：
1 <= deadends.length <= 500
deadends[i].length == 4
target.length == 4
target 不在 deadends 之中
target 和 deadends[i] 仅由若干位数字组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/open-the-lock
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

因为转盘锁是一步步地解锁的，而且是数字的排列组合，因此可以使用BFS进行解答

首先把deadends[]数组元素放入一个Set集合set中，用于后面检验的操作

再设置一个Set集合seen，表示已经遍历过的数字排列

凡是出现在seen和set两个集合中的元素，都不能在此分支下继续遍历

利用Queue对象进行BFS，另外每一步操作会对四个数字进行加减1的操作，也就是下一步会产生8个新的分支。BFS的每一层代表一步，可通过一个变量进行步数的存储，待最后返回

代码详解

class Solution {
    public int openLock(String[] deadends, String target) {
        if(target.equals("0000")) { // 若目标就为0000，则0步
            return 0;
        }
        Set<String> set = new HashSet<>(); // set集合存放deadends中的元素
        for(String s : deadends) {
            set.add(s);
        }
        if(set.contains("0000")) { // 若deadends元素中有初始值0000，则说明无法到达目标
            return -1;
        }
        Set<String> seen = new HashSet<>(); // seen集合存放已遍历过的数字排列
        seen.add("0000"); // 初始化时也把初始值0000放进去
        // BFS
        Queue<String> queue = new LinkedList<>();
        queue.offer("0000");
        int step = 0; // 步数
        while(!queue.isEmpty()) {
            for(int i = queue.size(); i > 0; --i) { // 用queue.size()作为初值保证遍历完整一层后step才+1
                String num = queue.poll();
                if(num.equals(target)) { // 如果是target就直接返回step
                    return step;
                }
                // 如果不是则将最多8种分支进行入队，入队前进行判断，符合要求才能入队
                for(String s : getStrings(num)) {
                    if(!set.contains(s) && seen.add(s)) {
                        queue.offer(s);
                    }
                }
            }
            // 代码运行至此说明一层已经完全遍历完毕，深度会+1，即step+1
            ++step;
        }
        // 代码运行至此说明无法到达target，返回-1
        return -1;
    }

	// 获取8种分支的方法
    public List<String> getStrings(String s) {
        List<String> list = new ArrayList<>();
        char[] cs = s.toCharArray();
        for(int i = 0; i < 4; ++i) {
            list.add(String.valueOf(nextNum(cs, i))); // 第i位正拨
            cs = preNum(cs, i); // 复原
            list.add(String.valueOf(preNum(cs, i))); // 第i位反拨
            cs = nextNum(cs, i); // 复原
        }
        return list;
    }

	// 正拨
    public char[] nextNum(char[] cs, int i) {
        if(cs[i] == '9') {
            cs[i] = '0';
        } else {
            cs[i] += 1;
        }
        return cs;
    }

	// 反拨
    public char[] preNum(char[] cs, int i) {
        if(cs[i] == '0') {
            cs[i] = '9';
        } else {
            cs[i] -= 1;
        }
        return cs;
    }
}

注意点

1. 只让符合条件的排列入队，可以省去大量多余的分支
2. 注意9变0、0变9的操作
3. 此题可优化为双向BFS，可查看官方题解