Open the Lock - Practice Coding Problems

Open the Lock - Problem

Imagine you're a master thief standing before a sophisticated 4-digit combination lock. Each digit can be rotated from 0 to 9, and the wheels wrap around (so 9 becomes 0 and vice versa).

The lock starts at "0000" and you need to reach a specific target combination to unlock it. However, there's a catch - certain combinations are deadends that will trigger an alarm and lock you out forever!

Your mission: Find the minimum number of wheel turns needed to reach the target, or return -1 if it's impossible.

Rules:

Each move rotates exactly one wheel by one position
Wheels wrap around: 0 → 9 and 9 → 0
Avoid all deadend combinations
Find the shortest path from "0000" to target

Input & Output

example_1.py — Basic Case

$ Input: deadends = ["0201","0101","0102","1212","2002"], target = "0202"

› Output: 6

💡 Note: The shortest path is: 0000 → 1000 → 1100 → 1200 → 1201 → 1202 → 0202. We avoid deadends and find the minimum 6 moves.

example_2.py — Impossible Case

$ Input: deadends = ["8888"], target = "0009"

› Output: 1

💡 Note: We can turn the last wheel from 0000 to 0009 in just 1 move. The deadend 8888 doesn't block our path.

example_3.py — Blocked Start

$ Input: deadends = ["0000"], target = "8888"

› Output: -1

💡 Note: The starting position 0000 is a deadend, so we cannot make any moves. Return -1 as it's impossible.

Constraints

1 ≤ deadends.length ≤ 500
deadends[i].length == 4
target.length == 4
target will not be in the list deadends
target and deadends[i] consist of digits only

Visualization

Tap to expand

Understanding the Visualization

Start at Ground Floor

Begin at room 0000 on floor 0

Explore Floor 1

Visit all rooms reachable in 1 move

Explore Floor 2

Visit all rooms reachable in 2 moves

Continue Until Target

The floor number when we find the target is our answer

Key Takeaway

🎯 Key Insight: BFS explores by distance levels, guaranteeing the shortest path to any reachable combination!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses Breadth-First Search (BFS) to explore all combinations level by level. BFS guarantees that the first time we reach the target combination, it's via the shortest path. We use a queue to process combinations and a hash set to avoid revisiting states, achieving O(10^4) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Depth-First Search (DFS)	O(10^4 * 8^d)	O(d)	Recursively explore all possible paths using backtracking
Breadth-First Search (BFS) - Optimal	O(10^4)	O(10^4)	Use BFS with queue to find shortest path level by level

Depth-First Search (DFS) — Algorithm Steps

Start from '0000' and use DFS to explore all neighbors
For each combination, try turning each wheel up and down
Skip deadends and already visited combinations
Track the minimum steps needed to reach target
Use backtracking to explore all possible paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at 0000

Begin DFS from initial combination

Explore first path deeply

Follow one branch as far as possible

Backtrack when stuck

Return and try alternative paths

Continue until target found

May take longer but will find a solution

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_COMBINATIONS 10000

bool isDeadend(char** deadends, int deadendsSize, char* combination) {
    for (int i = 0; i < deadendsSize; i++) {
        if (strcmp(deadends[i], combination) == 0) {
            return true;
        }
    }
    return false;
}

bool isVisited(char visited[][5], int visitedCount, char* combination) {
    for (int i = 0; i < visitedCount; i++) {
        if (strcmp(visited[i], combination) == 0) {
            return true;
        }
    }
    return false;
}

void getNeighbors(char* combination, char neighbors[][5], int* count) {
    *count = 0;
    for (int i = 0; i < 4; i++) {
        int digit = combination[i] - '0';
        
        strcpy(neighbors[*count], combination);
        neighbors[*count][i] = '0' + (digit + 1) % 10;
        (*count)++;
        
        strcpy(neighbors[*count], combination);
        neighbors[*count][i] = '0' + (digit + 9) % 10;
        (*count)++;
    }
}

int dfs(char* current, char* target, char** deadends, int deadendsSize, 
        char visited[][5], int visitedCount, int steps) {
    if (strcmp(current, target) == 0) {
        return steps;
    }
    
    int minSteps = 1000000;
    char neighbors[8][5];
    int neighborCount;
    getNeighbors(current, neighbors, &neighborCount);
    
    for (int i = 0; i < neighborCount; i++) {
        if (!isDeadend(deadends, deadendsSize, neighbors[i]) && 
            !isVisited(visited, visitedCount, neighbors[i])) {
            
            strcpy(visited[visitedCount], neighbors[i]);
            int result = dfs(neighbors[i], target, deadends, deadendsSize, 
                           visited, visitedCount + 1, steps + 1);
            if (result < minSteps) {
                minSteps = result;
            }
        }
    }
    
    return minSteps == 1000000 ? -1 : minSteps;
}

int openLock(char** deadends, int deadendsSize, char* target) {
    if (isDeadend(deadends, deadendsSize, "0000")) {
        return -1;
    }
    if (strcmp(target, "0000") == 0) {
        return 0;
    }
    
    char visited[MAX_COMBINATIONS][5];
    strcpy(visited[0], "0000");
    
    return dfs("0000", target, deadends, deadendsSize, visited, 1, 0);
}

Time & Space Complexity

Time Complexity

⏱️

O(10^4 * 8^d)

10^4 possible combinations, each with 8 neighbors, exploring up to depth d

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d for the path length

✓ Linear Space

95.4K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Depth-First Search (DFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler