本文介绍了解决转盘锁问题的方法，包括广度优先搜索和启发式搜索两种算法。通过具体的示例展示了如何寻找解锁所需的最小旋转次数。
题目
题干
你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。
锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。
列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。
字符串 target 代表可以解锁的数字，你需要给出解锁需要的最小旋转次数，如果无论如何不能解锁，返回 -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:
输入: deadends = [“8888”], target = “0009”
输出：1
解释：把最后一位反向旋转一次即可 “0000” -> “0009”。
示例 3:
输入: deadends = [“8887”,“8889”,“8878”,“8898”,“8788”,“8988”,“7888”,“9888”], target = “8888”
输出：-1
解释：无法旋转到目标数字且不被锁定。
提示：
1 <= deadends.length <= 500
deadends[i].length == 4
target.length == 4
target 不在 deadends 之中
target 和 deadends[i] 仅由若干位数字组成
题解
方法一：广度优先搜索
思路与算法
我们可以使用广度优先搜索，找出从初始数字 0000 到解锁数字target 的最小旋转次数。
具体地，我们在一开始将 (0000,0) 加入队列，并使用该队列进行广度优先搜索。在搜索的过程中，设当前搜索到的数字为 status，旋转的次数为step，我们可以枚举 status 通过一次旋转得到的数字。设其中的某个数字为 next_status，如果其没有被搜索过，我们就将(next_status,step+1) 加入队列。如果搜索到了target，我们就返回其对应的旋转次数。
为了避免搜索到死亡数字，我们可以使用哈希表存储 deadends 中的所有元素，这样在搜索的过程中，我们可以均摊 O(1) 地判断一个数字是否为死亡数字。同时，我们还需要一个哈希表存储所有搜索到的状态，避免重复搜索。
如果搜索完成后，我们仍没有搜索到target，说明我们无法解锁，返回 −1。
细节
本题中需要注意如下两个细节：
如果 \textit{target}target 就是初始数字 0000，那么直接返回答案 0；
如果初始数字 0000 出现在deadends 中，那么直接返回答案 −1。
class Solution {
public int openLock(String[] deadends, String target) {
if ("0000".equals(target)) {
return 0;
}
Set<String> dead = new HashSet<String>();
for (String deadend : deadends) {
dead.add(deadend);
}
if (dead.contains("0000")) {
return -1;
}
int step = 0;
Queue<String> queue = new LinkedList<String>();
queue.offer("0000");
Set<String> seen = new HashSet<String>();
seen.add("0000");
while (!queue.isEmpty()) {
++step;
int size = queue.size();
for (int i = 0; i < size; ++i) {
String status = queue.poll();
for (String nextStatus : get(status)) {
if (!seen.contains(nextStatus) && !dead.contains(nextStatus)) {
if (nextStatus.equals(target)) {
return step;
}
queue.offer(nextStatus);
seen.add(nextStatus);
}
}
}
}
return -1;
}
public char numPrev(char x) {
return x == '0' ? '9' : (char) (x - 1);
}
public char numSucc(char x) {
return x == '9' ? '0' : (char) (x + 1);
}
// 枚举 status 通过一次旋转得到的数字
public List<String> get(String status) {
List<String> ret = new ArrayList<String>();
char[] array = status.toCharArray();
for (int i = 0; i < 4; ++i) {
char num = array[i];
array[i] = numPrev(num);
ret.add(new String(array));
array[i] = numSucc(num);
ret.add(new String(array));
array[i] = num;
}
return ret;
}
}
复杂度分析
时间复杂度：O(bd⋅d2+md)，其中 b 是数字的进制，d 是转盘数字的位数，m 是数组 deadends 的长度，在本题中 b=10,d=4。转盘数字的可能性一共有 bd种，这也是我们可以搜索到的状态数上限。对于每一个转盘数字，我们需要 O(d) 的时间枚举旋转的数位，同时需要 O(d) 的时间生成旋转后的数字（即加入队列），因此广度优先搜索的总时间复杂度为 O(bd⋅d2+md)。
此外，在搜索前我们需要将deadends 中的所有元素放入哈希表中，计算一个字符串哈希值需要的时间为 O(d)，因此需要的总时间为 O(md)。
空间复杂度：O(b^d⋅d+m)。
我们最多需要在队列中存储 O(bd)) 个长度为 d 的字符串，空间复杂度为 O(bd⋅d)；
哈希表需要 O(m) 的空间。如果使用的语言存储的是元素的拷贝，那么需要的空间为 O(md)。
方法二：启发式搜索
概念
我们可以使用启发式搜索更快地找到最小旋转次数。这里我们可以使用 A* 算法。
读者可以自行查阅资料学习关于A* 算法的基础知识，例如 Wikipedia - A* search algorithm 或 oi-wiki - A*。它不是本题解的重点，因此这里不再赘述。读者可以阅读下面的段落检验自己的学习成果：
在 A* 算法中，我们需要使用四个距离函数F(x),G(x),H(x),H∗(x)，其中 F(x),G(x),H(x) 是可以求出的，而 H^(x)H∗
(x) 是无法求出的，我们需要用 H(x) 近似 H^(x)H * (x)。设起点为 s，终点为 t，这些距离函数的意义如下：
G(x) 表示从起点 s 到节点 x 的「实际」路径长度，注意 G(x) 并不一定是最短的；
H(x) 表示从节点 x 到终点 t 的「估计」最短路径长度，称为启发函数；
H^(x)H ∗(x) 表示从节点 x 到终点 t 的「实际」最短路径长度，这是我们在广度优先搜索的过程中无法求出的，我们需要用 H(x) 近似 H^(x)H ∗ (x)；
F(x) 满足 F(x) = G(x) + H(x)，即为从起点 s 到终点 t 的「估计」路径长度。我们总是挑选出最小的 F(x) 对应的 x 进行搜索，因此 A* 算法需要借助优先队列来实现。
如果读者熟悉求解最短路的 Dijkstra 算法，就可以发现Dijkstra 算法是A* 算法在H(x)≡0 时的特殊情况。
A* 算法具有两个性质：
如果对于任意的节点 x，H(x)≤H ∗ (x) 恒成立，即我们「估计」出的从节点 x 到终点 t 的最短路径长度总是不超过「实际」的最短路径长度，那么称启发函数 H(x) 是可接纳的（admissible heuristic）。在这种情况下，A* 算法一定能找到最短路，但同一节点可能需要加入优先队列并搜索多次，即当我们从优先队列中取出节点 x 时，G(x) 并不一定等于从起点到节点 x 的「实际」最短路径的长度；
如果对于任意的两个节点 x 和 y，并且 x 到 y 有一条长度为D(x,y) 的有向边，H(x)−H(y)≤D(x,y) 恒成立，并且 H(t)=0，那么称启发函数 H(x) 是一致的（consistent heuristic）。可以证明，一致的启发函数一定也是可接纳的。在这种情况下，同一节点只会被加入优先队列一次，并搜索不超过一次，即当我们从优先队列中取出节点 x 时，G(x) 一定等于从起点到节点 x 的「实际」最短路径的长度。
思路与算法
我们可以设计如下的启发函数：
H(status)=
i=0
∑ ( 将 status 的第 i 个数字旋转到与 target 的第 i 个数字一致，最少需要的次数 )
3
即H(status) 等于不存在死亡数字时最小的旋转次数。根据定义，对于数字 status 和其通过一次旋转得到的数字 next_status，H(status)−H(next_status) 要么为 1（旋转的那一个数位与target 更近了），要么为 -1（旋转的那一个数位与 target 更远了），而 D(status,next_status)=1，因此我们设计的启发函数是一致的。
我们在A* 算法中使用该启发函数，即可得到最小的旋转次数。
class Solution {
public int openLock(String[] deadends, String target) {
if ("0000".equals(target)) {
return 0;
}
Set<String> dead = new HashSet<String>();
for (String deadend : deadends) {
dead.add(deadend);
}
if (dead.contains("0000")) {
return -1;
}
PriorityQueue<AStar> pq = new PriorityQueue<AStar>((a, b) -> a.f - b.f);
pq.offer(new AStar("0000", target, 0));
Set<String> seen = new HashSet<String>();
seen.add("0000");
while (!pq.isEmpty()) {
AStar node = pq.poll();
for (String nextStatus : get(node.status)) {
if (!seen.contains(nextStatus) && !dead.contains(nextStatus)) {
if (nextStatus.equals(target)) {
return node.g + 1;
}
pq.offer(new AStar(nextStatus, target, node.g + 1));
seen.add(nextStatus);
}
}
}
return -1;
}
public char numPrev(char x) {
return x == '0' ? '9' : (char) (x - 1);
}
public char numSucc(char x) {
return x == '9' ? '0' : (char) (x + 1);
}
// 枚举 status 通过一次旋转得到的数字
public List<String> get(String status) {
List<String> ret = new ArrayList<String>();
char[] array = status.toCharArray();
for (int i = 0; i < 4; ++i) {
char num = array[i];
array[i] = numPrev(num);
ret.add(new String(array));
array[i] = numSucc(num);
ret.add(new String(array));
array[i] = num;
}
return ret;
}
}
class AStar {
String status;
int f, g, h;
public AStar(String status, String target, int g) {
this.status = status;
this.g = g;
this.h = getH(status, target);
this.f = this.g + this.h;
}
// 计算启发函数
public static int getH(String status, String target) {
int ret = 0;
for (int i = 0; i < 4; ++i) {
int dist = Math.abs(status.charAt(i) - target.charAt(i));
ret += Math.min(dist, 10 - dist);
}
return ret;
}
}
复杂度分析
启发式搜索不讨论时空复杂度。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
