# Open the Lock

You have a lock in front of you with 4 circular wheels. Each wheel has 10 slots:`'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'`. The wheels can rotate freely and wrap around: for example we can turn`'9'`to be`'0'`, or`'0'`to be`'9'`. Each move consists of turning one wheel one slot.

The lock initially starts at`'0000'`, a string representing the state of the 4 wheels.

You are given a list of`deadends`dead ends, meaning if the lock displays any of these codes, the wheels of the lock will stop turning and you will be unable to open it.

Given a`target`representing the value of the wheels that will unlock the lock, return the minimum total number of turns required to open the lock, or -1 if it is impossible.

Example 1:

``````Input: deadends = ["0201","0101","0102","1212","2002"], target = "0202"
Output: 6
Explanation:
A sequence of valid moves would be "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202".
Note that a sequence like "0000" -> "0001" -> "0002" -> "0102" -> "0202" would be invalid,
because the wheels of the lock become stuck after the display becomes the dead end "0102".``````

Example 2:

``````Input: deadends = ["8888"], target = "0009"
Output: 1
Explanation:
We can turn the last wheel in reverse to move from "0000" -> "0009".``````

Example 3:

``````Input: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
Output: -1
Explanation:
We can't reach the target without getting stuck.``````

Example 4:

``````Input: deadends = ["0000"], target = "8888"
Output: -1``````

Note:

1. The length of `deadends` will be in the range `[1, 500]`.

2. `target` will not be in the list `deadends`.

3. Every string in `deadends` and the string `target` will be a string of 4 digits from the 10,000 possibilities`'0000'` to `'9999'`.

## Analysis

lock的每一个状态都可以看成一个节点，是否能从一个状态到另一个状态，看成节点之间是否右边，这个问题就转化为了一个图中最短路径shortest path的问题。target就是目标节点，deadends就是不能连通的节点。

Why not DFS?

Because the problem here asks for the minimum number of steps to achieve the target state. Using BFS, we can report the answer as long as we reach the target state. But using DFS, we can't guarantee that the initial target state that we reach is the optimal solution. You still have to search the whole search space. Think about the problem that to find the depth of a binary tree, it is quite similar in this sense.

### Approach 1: Regular BFS

BFS在求shortest path时，要注意何时增加搜索的layer数。一般来说就是用一个layerSize变量记录进入每个layer初始时的大小，内层循环中每poll()一次就减小layerSize，直到layerSize变为0，则层数+1，进入下一个外层循环。

1. 每个wheel可以正向也可以反向旋转，因此每次BFS节点生成下一层的搜索节点时，实际上会有8个待搜索节点：4个wheel，每个wheel +1 or -1，4 * 2 = 8，这样写循环时可以用两重循环遍历这4*2个新节点。

2. 要搜索的是字符串，但是生成新搜索节点时要一次改变一个字符，Java中字符串是immutable，就需要考虑用char array或者string builder，或者最普通的加号（+）string concatenation。根据不同的情形可以有如下实现方式：

1. 字符数组（要注意每次修改完一个字符生成新字符串后，要还原这一个字符以便进行下一个循环）`chs[i] = (char)((chTmp - '0' + d + 10) % 10 + '0'); String newStr = new String(chs);`

2. string builder：`String s1 = sb.substring(0, i) + (c == '9' ? 0 : c - '0' + 1) + sb.substring(i + 1); String s2 = sb.substring(0, i) + (c == '0' ? 9 : c - '0' - 1) + sb.substring(i + 1);`

3. 字符串拼接：`int y = ((node.charAt(i) - '0') + d + 10) % 10;` 然后字符串拼接：`String nei = node.substring(0, i) + ("" + y) + node.substring(i+1);`

Complexity

• Time Complexity: `O(N^2 * A^N+D)` where `A` is the number of digits in our alphabet, `N` is the number of digits in the lock, andDDis the size of`deadends`. We might visit every lock combination, plus we need to instantiate our set`dead`. When we visit every lock combination, we spend `O(N^2)` time enumerating through and constructing each node.

• Space Complexity: `O(A^N + D)`, for the`queue`and the set`dead`.

### Approach 2: Bi-directional (2-end) BFS

If you know exactly the start position and the end position(In this problem, the start position is "0000" and the end position is target), you can do BFS from both side instead of doing BFS only from the starting position.You find the intersection, you get the result. Otherwise, if you do not know what the end point is, you can't use 2 - end BFS (eg. maze problem, as you wouldn't be able to know the exit postion).

By always picking a smaller set..

## Solution

BFS - (114 ms, faster than 83.92%)

``````class Solution {
public int openLock(String[] deadends, String target) {
int minNumOfTurns = 0;
HashSet<String> visited = new HashSet<>();
HashSet<String> deadendsSet = new HashSet<>();
for (String deadend : deadends) {
deadendsSet.add(deadend);
}
// init lock wheels
char[] wheels = new char[4];
for (int i = 0; i < 4; i++) {
wheels[i] = '0';
}
Queue<String> queue = new LinkedList<String>();
// init BFS
queue.offer("0000");

while (!queue.isEmpty()) {
int layerSize = queue.size();
while (layerSize > 0) {
String str = queue.poll();
if (deadendsSet.contains(str)) {
layerSize--;
continue;
}

if (str.equals(target)) {
return minNumOfTurns;
}
char[] chs = str.toCharArray();
for (int i = 0; i < chs.length; i++) {
char chTmp = chs[i];
for (int d = -1; d <= 1; d += 2) {
chs[i] = (char)((chTmp - '0' + d + 10) % 10 + '0');
String newStr = new String(chs);
if (!visited.contains(newStr) && !deadendsSet.contains(newStr)) {
queue.offer(newStr);
visited.add(newStr);
}
}
chs[i] = chTmp;
}
layerSize--;
}
minNumOfTurns++;
}
return  -1;
}
}``````

Bi-direction 2-end BFS (79 ms) @yaoyimingg

``````class Solution {
public int openLock(String[] deadends, String target) {
Set<String> begin = new HashSet<>();
Set<String> end = new HashSet<>();
Set<String> deads = new HashSet<>(Arrays.asList(deadends));
begin.add("0000");
end.add(target);
int level = 0;
Set<String> temp;
while(!begin.isEmpty() && !end.isEmpty()) {
if (begin.size() > end.size()) {
temp = begin;
begin = end;
end = temp;
}
temp = new HashSet<>();
for(String s : begin) {
if(end.contains(s)) return level;
if(deads.contains(s)) continue;
deads.add(s);
StringBuilder sb = new StringBuilder(s);
for(int i = 0; i < 4; i ++) {
char c = sb.charAt(i);
String s1 = sb.substring(0, i) + (c == '9' ? 0 : c - '0' + 1) + sb.substring(i + 1);
String s2 = sb.substring(0, i) + (c == '0' ? 9 : c - '0' - 1) + sb.substring(i + 1);
if(!deads.contains(s1))
temp.add(s1);
if(!deads.contains(s2))
temp.add(s2);
}
}
level ++;
begin = temp;
}
return -1;
}
}``````

LeetCode Solution

``````class Solution {
public int openLock(String[] deadends, String target) {
Set<String> dead = new HashSet();
for (String d: deadends) dead.add(d);

Queue<String> queue = new LinkedList();
queue.offer("0000");
queue.offer(null);

Set<String> seen = new HashSet();
seen.add("0000");

int depth = 0;
while (!queue.isEmpty()) {
String node = queue.poll();
if (node == null) {
depth++;
if (queue.peek() != null)
queue.offer(null);
} else if (node.equals(target)) {
return depth;
} else if (!dead.contains(node)) {
for (int i = 0; i < 4; ++i) {
for (int d = -1; d <= 1; d += 2) {
int y = ((node.charAt(i) - '0') + d + 10) % 10;
String nei = node.substring(0, i) + ("" + y) + node.substring(i+1);
if (!seen.contains(nei)) {
seen.add(nei);
queue.offer(nei);
}
}
}
}
}
return -1;
}
}``````

## Reference

Official Solution:

https://leetcode.com/problems/open-the-lock/solution/

#### Regular java BFS solution and 2-end BFS solution with improvement

https://leetcode.com/problems/open-the-lock/discuss/110237/Regular-java-BFS-solution-and-2-end-BFS-solution-with-improvement

Bi-directional Search: https://www.geeksforgeeks.org/bidirectional-search/

Last updated