Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
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 cannot reach the target without getting stuck.
Constraints:
1 <= deadends.length <= 500
deadends[i].length == 4
target.length == 4
deadends
.target
and deadends[i]
consist of digits only. def openLock(self, deadends, target):
marker, depth = 'x', -1
visited, q = set(deadends), deque(['0000'])
while q:
size = len(q)
depth += 1
for _ in range(size):
node = q.popleft()
if node == target: return depth
if node in visited: continue
visited.add(node)
q.extend(self.successors(node))
return -1
def successors(self, src):
res = []
for i, ch in enumerate(src):
num = int(ch)
res.append(src[:i] + str((num - 1) % 10) + src[i+1:])
res.append(src[:i] + str((num + 1) % 10) + src[i+1:])
return res
public static int openLock(String[] deadends, String target) {
Queue<String> q = new LinkedList<>();
Set<String> visited = new HashSet<>(Arrays.asList(deadends));
int depth = -1;
q.addAll(Arrays.asList("0000"));
while(!q.isEmpty()) {
depth++;
int size = q.size();
for(int i = 0; i < size; i++) {
String node = q.poll();
if(node.equals(target))
return depth;
if(visited.contains(node))
continue;
visited.add(node);
q.addAll(getSuccessors(node));
}
}
return -1;
}
private static List<String> getSuccessors(String str) {
List<String> res = new LinkedList<>();
for (int i = 0; i < str.length(); i++) {
res.add(str.substring(0, i) + (str.charAt(i) == '0' ? 9 : str.charAt(i) - '0' - 1) + str.substring(i+1));
res.add(str.substring(0, i) + (str.charAt(i) == '9' ? 0 : str.charAt(i) - '0' + 1) + str.substring(i+1));
}
return res;
}
class Solution {
public:
int openLock(vector<string>& deadends, string target) {
unordered_set<string> dds(deadends.begin(), deadends.end());
unordered_set<string> visited;
queue<string> bfs;
string init = "0000";
if (dds.find(init) != dds.end()) return -1;
visited.insert("0000");
bfs.push("0000");
int res = 0;
while (!bfs.empty()) {
int sz = bfs.size();
for (int i = 0; i < sz; i++) {
string t = bfs.front(); bfs.pop();
vector<string> nbrs = move(nbrStrs(t));
for (auto s : nbrs) {
if (s == target) return ++res;
if (visited.find(s) != visited.end()) continue;
if (dds.find(s) == dds.end()) {
bfs.push(s);
visited.insert(s);
}
}
}
++res;
}
return -1;
}
vector<string> nbrStrs(string key) {
vector<string> res;
for (int i = 0 ; i < 4; i++) {
string tmp = key;
tmp[i] = (key[i] - '0' + 1) % 10 + '0';
res.push_back(tmp);
tmp[i] = (key[i] - '0' - 1 + 10) % 10 + '0';
res.push_back(tmp);
}
return res;
}
};
In our experience, we suggest you solve this Open the Lock LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.
If you are stuck anywhere between any coding problem, just visit Queslers to get the Open the Lock LeetCode Solution
I hope this Open the Lock LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.
This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.
Keep Learning!
More Coding Solutions >>