题目描述
LeetCode题目地址：剑指 Offer II 109. 开密码锁、同752. 打开转盘锁
一个密码锁由 4 个环形拨轮组成，每个拨轮都有 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
解释：无法旋转到目标数字且不被锁定。
示例 4:
输入: deadends = [“0000”], target = “8888”
输出：-1
提示：
1 <= deadends.length <= 500
deadends[i].length == 4
target.length == 4
target 不在 deadends 之中
target 和 deadends[i] 仅由若干位数字组成
解决思路
题目中求解最小旋转次数，根据密码锁转盘场景，每个密码旋转一次共有8种可能，比如1290旋转一次后可能的结果有2290、0290、1390、1190、1280、1200、1291、1299，即四个数字每个数字可选择“向上拨”或者“向下拨”，即与1290相邻的所有子节点已经求出。
因此本题简化为BFS模板题，利用BFS求解0000到目标节点的“最短路径”，因路径中存在“障碍”（题目中所提到的死亡数字），只需舍弃存在障碍的路径即可。
BFS解题板子
BFS模板：While循环+队列
分支限界法（BFS、广度优先搜索）：每一个活结点只有一次机会成为扩展结点，一旦活结点成为了扩展结点，就一次性产生其所有的儿子结点。其目标为尽快找出满足约束条件的一个解。
// 计算从起点 start 到终点 target 的最近距离
int BFS(Node start, Node target) {
Queue<Node> q; // 核心数据结构
Set<Node> visited; // 用于记录某个点是否走过，避免走回头路，在二维矩阵迷宫常用boolean[][]记录某个点x，y是否走过
q.offer(start); // 将起点加入队列
visited.add(start);
int step = 0; // 记录扩散的步数
while (q not empty) {
int sz = q.size();
/* 将当前队列中的所有节点向四周扩散 */
for (int i = 0; i < sz; i++) {
Node cur = q.poll();
/* 划重点：这里判断是否到达终点 */
if (cur is target)
return step;
/* 将 cur 的相邻节点加入队列 */
for (Node x : cur.adj()) { // 一旦活结点成为了扩展结点，就一次性产生其所有的儿子结点。
if (x not in visited) {
q.offer(x);
visited.add(x);
}
}
}
/* 划重点：更新步数在这里 */
step++;
}
}
以上模板来自东哥总结，地址：labuladong
代码实现
第一步：先实现一个方法，用于返回每个密码旋转一次的共有8种可能结果，输入String返回List。
思路：将String转换为char数组，处理数组中的每个char，然后放入List。
/**
* 用于求解每个密码旋转一次后的8种可能情况
* @param str
* @return List<String>
*/
List<String> child_node(String str){
List<String> list = new ArrayList<String>();
char[] chars = str.toCharArray();
char[] newchars = chars;
int N = 4;
for (int i = 0; i < N; i++) {
newchars = chars.clone();// 重要：使用clone拷贝
if (newchars[i] == '0'){ // 处理特殊0，可变为1或9
newchars[i] = '1';
list.add(String.valueOf(newchars));
newchars[i] = '9';
list.add(String.valueOf(newchars));
}else if (newchars[i] == '9'){ // 处理特殊9，可变为0或8
newchars[i] = '8';
list.add(String.valueOf(newchars));
newchars[i] = '0';
list.add(String.valueOf(newchars));
}else { // 常规情况
char c = newchars[i];
newchars[i] =(char)(c+1);
list.add(String.valueOf(newchars));
newchars[i] =(char)(c-1);
list.add(String.valueOf(newchars));
}
}
return list;
}
注意char数组与String的相互转换。
char[] chars = str.toCharArray();
String news = String.valueOf(chars)
第二步：然后套用BFS板子
注意处理特殊情况，如“0000”为死亡数字，则直接返回-1
/**
* 主方法
* @param deadends 死亡数组
* @param target 目标密码
* @return 最小旋转次数
*/
public int openLock(String[] deadends, String target) {
// 将死亡数字存储在set中，方便用contains判断
Set<String> dead_set = new HashSet<>();
for (String deadend : deadends) {
dead_set.add(deadend);
}
// BFS队列
Queue<String> queue = new LinkedList<>();
// BFS中用于记录某次节点（某个密码）是否走过
Set<String> visited = new HashSet<>();
// 处理特殊情况
if(dead_set.contains("0000"))return -1;
// 将初始节点放入队列中
queue.add("0000");
visited.add("0000");
// BFS遍历开始
int step = 0;
while (!queue.isEmpty()){
int siz = queue.size();
for (int i = 0; i < siz ;i++) {
String cur = queue.poll();
/* 划重点：这里判断是否到达终点 */
if(cur.equals(target))return step;
/* 将 cur 的相邻节点加入队列 */
List<String> sorrounds = child_node(cur);
for(String s : sorrounds){
// 舍弃死亡数字和已走过的点
if(dead_set.contains(s))continue;
if(visited.contains(s))continue;
queue.add(s);
visited.add(s);
}
}
step++;
}
return -1; // 无论如何不能解锁，返回 -1 。
}
力扣提交完整代码如下：
class Solution {
/**
* 主方法
* @param deadends 死亡数组
* @param target 目标密码
* @return 最小旋转次数
*/
public int openLock(String[] deadends, String target) {
// 将死亡数字存储在set中，方便用contains判断
Set<String> dead_set = new HashSet<>();
for (String deadend : deadends) {
dead_set.add(deadend);
}
// BFS队列
Queue<String> queue = new LinkedList<>();
// BFS中用于记录某次节点（某个密码）是否走过
Set<String> visited = new HashSet<>();
// 处理特殊情况
if(dead_set.contains("0000"))return -1;
// 将初始节点放入队列中
queue.add("0000");
visited.add("0000");
// BFS遍历开始
int step = 0;
while (!queue.isEmpty()){
int siz = queue.size();
for (int i = 0; i < siz ;i++) {
String cur = queue.poll();
/* 划重点：这里判断是否到达终点 */
if(cur.equals(target))return step;
/* 将 cur 的相邻节点加入队列 */
List<String> sorrounds = child_node(cur);
for(String s : sorrounds){
// 舍弃死亡数字和已走过的点
if(dead_set.contains(s))continue;
if(visited.contains(s))continue;
queue.add(s);
visited.add(s);
}
}
step++;
}
return -1; // 无论如何不能解锁，返回 -1 。
}
/**
* 用于求解每个密码旋转一次后的8种可能情况
* @param str
* @return List<String>
*/
List<String> child_node(String str){
List<String> list = new ArrayList<String>();
char[] chars = str.toCharArray();
char[] newchars = chars;
int N = 4;
for (int i = 0; i < N; i++) {
newchars = chars.clone();
if (newchars[i] == '0'){
newchars[i] = '1';
list.add(String.valueOf(newchars));
newchars[i] = '9';
list.add(String.valueOf(newchars));
}else if (newchars[i] == '9'){
newchars[i] = '8';
list.add(String.valueOf(newchars));
newchars[i] = '0';
list.add(String.valueOf(newchars));
}else {
char c = newchars[i];
newchars[i] =(char)(c+1);
list.add(String.valueOf(newchars));
newchars[i] =(char)(c-1);
list.add(String.valueOf(newchars));
}
}
return list;
}
}
解答成功:
执行耗时:176 ms,击败了6.48% 的Java用户
内存消耗:46.2 MB,击败了40.27% 的Java用户
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
