来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/open-the-lock
你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有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
提示：
死亡列表 deadends 的长度范围为 [1, 500]。
目标数字 target 不会在 deadends 之中。
每个 deadends 和 target 中的字符串的数字会在 10,000 个可能的情况 ‘0000’ 到 ‘9999’ 中产生。
/**
* 初始化char[] 为0000 目标String target xxxx
* 每次只能改变一个旋钮,共有8个选择,广度搜索,递归
* 不重复搜索,搜索过的记录保存到HashSet中
* 下一步搜索的结果也保存
*
* 思路是头和尾一起搜索,相遇了,两边的步数加起来就好
* 相遇判断: 初始已经搜索 和 结果已经搜索 是否有交集,有就相遇 步数1加步数2
* 或
* 初始下一步搜索 和 结果已经搜素 是否有交集 或者 结果下一步搜索 和 初始已经搜索 是否有交集 有的话,
* 步数1加步数2 加1
*
*/
public class GetKey {
public int openLock(String[] deadends, String target) {
//锁初始状态
String keyInit = "0000";
//将死锁转换为set
Set<String> dead = new HashSet<String>(Arrays.asList(deadends));
//如果锁初始锁死或目标值锁死,返回-1
if (dead.contains(keyInit) || dead.contains(target)){
return -1;
}
//如果初始值和目标值一样,则返回0
if (keyInit.equals(target)){
return 0;
}
//初始已经搜索节点 和 下一步搜索结果
Set<String> startSearched = new HashSet<>();
Set<String> startNext = new HashSet<>();
int startStep = 0;
startSearched.add(keyInit);
for(String key:getNextKeys(keyInit)){
if (!dead.contains(key)){
startNext.add(key);
}
}
//目标已经搜索节点 和 目标下一步搜索结果
Set<String> targetSearched = new HashSet<>();
Set<String> targetNext = new HashSet<>();
int targetStep = 0;
targetSearched.add(target);
for(String key:getNextKeys(target)){
if (!dead.contains(key)){
targetNext.add(key);
}
}
int stepChange = 0;
//开始广度搜索
while (!startNext.isEmpty() && !targetNext.isEmpty()){
//判断是否相遇,返回步数 -1 未相遇
stepChange = getStepChange(startSearched, startNext, targetSearched, targetNext);
if (stepChange<0){
//开始搜索下一步,变更已搜索节点
startSearched.addAll(startNext);
startStep +=1;
targetSearched.addAll(targetNext);
targetStep +=1;
//获取下一步搜索结果
Set<String> next_tmp_start = new HashSet<>();
Set<String> next_tmp_target = new HashSet<>();
for (String key:startNext){
for(String nextKey:getNextKeys(key)){
if (!dead.contains(nextKey) && !startSearched.contains(nextKey)){
next_tmp_start.add(nextKey);
}
}
}
for (String key:targetNext){
for(String nextKey:getNextKeys(key)){
if (!dead.contains(nextKey) && !targetSearched.contains(nextKey)){
next_tmp_target.add(nextKey);
}
}
}
startNext = next_tmp_start;
targetNext = next_tmp_target;
}else {
return startStep + targetStep + stepChange;
}
}
return -1;
}
//返回目标的下一状态
public List<String> getNextKeys(String now_key){
//存放结果
List<String> nextKeys = new ArrayList<>();
for (int i=0;i<now_key.length();i++){
StringBuilder stringBuilder = new StringBuilder(now_key);
char old_char = now_key.charAt(i);
//加1 特殊情况 9 变 0
char new_char = old_char =='9'? '0': (char)(old_char + 1);
stringBuilder.setCharAt(i,new_char);
nextKeys.add(stringBuilder.toString());
//减1 特殊情况 0变 9
new_char = old_char =='0'? '9': (char)(old_char - 1);
stringBuilder = new StringBuilder(now_key);
stringBuilder.setCharAt(i,new_char);
nextKeys.add(stringBuilder.toString());
}
return nextKeys;
}
/**
* 如果相遇,返回相遇所需要累加的步数,否则返回-1
*/
public int getStepChange(Set<String> startSearched,Set<String> startNest,Set<String> targetSearched,Set<String> targetNext){
if (isIntersection(startSearched,targetSearched)){
return 0;
}
if (isIntersection(startNest,targetSearched) || isIntersection(targetNext,startSearched)){
return 1;
}
return -1;
}
//判断两个set集合是否有交集
public boolean isIntersection(Set<String> s1,Set<String> s2){
Set<String> result = new HashSet<>();
result.addAll(s1);
result.retainAll(s2);
return !result.isEmpty();
}
}
参考链接:
https://blog.csdn.net/QingyunAlgo/article/details/80589440