Open the Lock

Open the Lock - Problem

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, 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.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: One shortest path: 0000 → 1000 → 1100 → 1200 → 1201 → 1202 → 0202. Each step turns one wheel by one position, avoiding all deadends.

Example 2 — Blocked Start

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

› Output: 1

💡 Note: Simple case: 0000 → 0009 (turn the last wheel once from 0 to 9). The deadend 8888 doesn't affect this path.

Example 3 — Impossible Case

$ Input: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"

› Output: -1

💡 Note: All neighbors of target 8888 are deadends, making it unreachable from 0000.

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

Asked in

a Amazon 15 G Google 12 M Microsoft 8 f Facebook 6

The key insight is to treat this as a shortest path problem in an unweighted graph. Each lock state is a node, and turning any wheel creates an edge to a neighboring state. BFS guarantees the minimum number of turns since all edges have equal weight (1 turn). Time: O(10⁴), Space: O(10⁴)

Common Approaches

✓ Breadth-First Search (Optimal)

⏱️ Time: O(10⁴) Space: O(10⁴)

BFS explores all states at distance 1, then distance 2, etc. Since each move has the same cost (1 turn), BFS guarantees finding the minimum number of turns. We use a queue to process states level by level.

Brute Force DFS

⏱️ Time: O(10⁴) Space: O(10⁴)

Recursively try all possible wheel rotations from current state, tracking visited states to avoid cycles. This explores all paths but doesn't guarantee finding the shortest path first.

Breadth-First Search (Optimal) — Algorithm Steps

Start with '0000' in queue at distance 0
For each state, generate all 8 neighbors (4 wheels × 2 directions)
Add unvisited, non-deadend neighbors to queue
Return distance when target is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with '0000' at distance 0

Level 1

Explore all states reachable in 1 move

Level 2

Find target at minimum distance

Code -

solution.c — C

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

#define MAX_QUEUE 20000
#define MAX_STATES 10000

typedef struct {
    char state[5];
    int steps;
} QueueItem;

typedef struct {
    char states[MAX_STATES][5];
    int count;
} StateSet;

bool contains(StateSet* set, char* state) {
    for (int i = 0; i < set->count; i++) {
        if (strcmp(set->states[i], state) == 0) {
            return true;
        }
    }
    return false;
}

void addState(StateSet* set, char* state) {
    if (!contains(set, state) && set->count < MAX_STATES) {
        strcpy(set->states[set->count], state);
        set->count++;
    }
}

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

int solution(char deadends[][5], int deadendCount, char* target) {
    StateSet dead = {0};
    for (int i = 0; i < deadendCount; i++) {
        addState(&dead, deadends[i]);
    }
    
    if (contains(&dead, "0000")) {
        return -1;
    }
    if (strcmp(target, "0000") == 0) {
        return 0;
    }
    
    StateSet visited = {0};
    addState(&visited, "0000");
    
    QueueItem queue[MAX_QUEUE];
    int front = 0, rear = 0;
    strcpy(queue[rear].state, "0000");
    queue[rear].steps = 0;
    rear++;
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        char neighbors[8][5];
        int neighborCount;
        getNeighbors(current.state, neighbors, &neighborCount);
        
        for (int i = 0; i < neighborCount; i++) {
            if (strcmp(neighbors[i], target) == 0) {
                return current.steps + 1;
            }
            
            if (!contains(&dead, neighbors[i]) && !contains(&visited, neighbors[i])) {
                addState(&visited, neighbors[i]);
                strcpy(queue[rear].state, neighbors[i]);
                queue[rear].steps = current.steps + 1;
                rear++;
            }
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse deadends array
    char deadends[1000][5];
    int deadendCount = 0;
    char* token = strtok(line, "[],\"\n ");
    while (token != NULL && deadendCount < 1000) {
        if (strlen(token) == 4) {
            strcpy(deadends[deadendCount], token);
            deadendCount++;
        }
        token = strtok(NULL, "[],\"\n ");
    }
    
    char target[5];
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;
    
    int result = solution(deadends, deadendCount, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10⁴)

Each of 10,000 possible states is visited at most once

✓ Linear Growth

Space Complexity

O(10⁴)

Queue and visited set can contain all possible lock states

✓ Linear Space

48.0K Views

Medium Frequency

~25 min Avg. Time

1.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

Breadth-First Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler