Shortest Path to Get All Keys - Practice Coding Problems

Shortest Path to Get All Keys - Problem

You're a treasure hunter navigating through an ancient dungeon! 🗝️ You've discovered a grid-based dungeon filled with keys and locked doors, and your goal is to collect all the keys using the minimum number of moves.

The dungeon layout consists of:

'.' - Empty spaces you can walk through
'#' - Walls that block your path
'@' - Your starting position
'a'-'f' - Keys you need to collect (lowercase letters)
'A'-'F' - Locked doors that require corresponding keys (uppercase letters)

Movement rules:

You can move in 4 cardinal directions (up, down, left, right)
You cannot move outside the grid or through walls
Walking over a key automatically picks it up
You can only pass through a locked door if you have its corresponding key

There are exactly 1-6 pairs of keys and locks, using the first k letters of the alphabet in order.

Goal: Return the minimum number of moves to collect all keys, or -1 if impossible.

Input & Output

simple_maze.py — Basic Example

$ Input: grid = ["@.a.#", "###.#", "b.A.B"]

› Output: 8

💡 Note: Start at @, move right to collect key 'a' (2 moves), go down and around to collect key 'b' (6 more moves total), then return to open door 'A'. Total: 8 moves to collect both keys.

impossible_case.py — No Solution

$ Input: grid = ["@..aA", "..#..", "....."]

› Output: -1

💡 Note: Key 'a' is available, but there's no corresponding lowercase 'A' door or path to collect all required keys. Since the problem states there must be exactly one key for each lock, this represents an impossible scenario.

single_key.py — Edge Case

$ Input: grid = ["@...a"]

› Output: 4

💡 Note: Simple case with one key. Start at position 0, move right 4 times to reach and collect the key 'a'. Since there's only one key to collect, we're done in 4 moves.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start at '@' with empty key collection (bitmask = 000)

BFS Level 1

Explore adjacent cells, collect any keys found

State Tracking

Track (row, col, key_bitmask) to avoid revisiting same situations

Door Logic

Check key requirements before passing through locked doors

Success Check

When key_bitmask equals (1<<k)-1, we have all keys!

Key Takeaway

🎯 Key Insight: Transform the problem into a state-space search where each state is (position + key collection). BFS ensures we find the shortest path efficiently!

Time & Space Complexity

Time Complexity

⏱️

O(m*n*2^k)

We have m*n positions and 2^k possible key states (k ≤ 6), each state processed once

✓ Linear Growth

Space Complexity

O(m*n*2^k)

Need to store visited states and BFS queue, both bounded by total number of possible states

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 30
grid[i][j] is a lowercase letter, uppercase letter, '.', '#', or '@'
The number of keys is in the range [1, 6]
There is exactly one lowercase and one uppercase letter of the first k letters of the English alphabet in the grid
1 ≤ k ≤ 6

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses BFS with state tracking where each state consists of (position, keys_collected). We represent keys as a bitmask for efficiency and use BFS to guarantee the shortest path. Time complexity is O(m×n×2^k) where k ≤ 6 keys.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with State Tracking (Optimal)	O(mn2^k)	O(mn2^k)	Use BFS with state (position + keys) to find shortest path efficiently
Brute Force (Try All Paths)	O(4^(m*n))	O(m*n)	Use DFS to explore all possible paths and key collection orders

BFS with State Tracking (Optimal) — Algorithm Steps

Represent key collection as a bitmask (bit i = 1 means key i is collected)
Use BFS queue with states: (row, col, keys_bitmask, moves)
For each state, try all 4 directions
Track visited states to avoid cycles: (row, col, keys_bitmask)
When we collect all keys (bitmask equals (1<<k)-1), return moves
If queue is empty and no solution found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start at (@, keys=000) with 0 moves

Explore Level 1

Try all adjacent cells, update key bitmasks

Track States

Each state is (row, col, key_bitmask)

Level by Level

BFS guarantees shortest path found first

Success

When key_bitmask equals 111...1 (all keys)

Code -

solution.c — C

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

#define MAX_QUEUE 100000
#define MAX_VISITED 10000

struct State {
    int row, col, keys, moves;
};

struct Queue {
    struct State data[MAX_QUEUE];
    int front, rear;
};

void enqueue(struct Queue* q, struct State s) {
    q->data[q->rear++] = s;
}

struct State dequeue(struct Queue* q) {
    return q->data[q->front++];
}

bool isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

int shortestPathAllKeys(char** grid, int gridSize, int* gridColSize) {
    int rows = gridSize;
    int cols = gridColSize[0];
    
    // Find starting position and count keys
    int startRow = 0, startCol = 0, keyCount = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            char c = grid[i][j];
            if (c == '@') {
                startRow = i;
                startCol = j;
            } else if (c >= 'a' && c <= 'f') {
                keyCount++;
            }
        }
    }
    
    // All keys collected when bitmask equals this
    int allKeys = (1 << keyCount) - 1;
    
    // BFS
    struct Queue queue = {.front = 0, .rear = 0};
    enqueue(&queue, (struct State){startRow, startCol, 0, 0});
    
    // Simple visited tracking (for small grids)
    bool visited[30][30][64] = {false}; // Max 30x30 grid, up to 6 keys
    visited[startRow][startCol][0] = true;
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    while (!isEmpty(&queue)) {
        struct State current = dequeue(&queue);
        int row = current.row, col = current.col, keys = current.keys, moves = current.moves;
        
        // Check if we collected all keys
        if (keys == allKeys) {
            return moves;
        }
        
        // Try all 4 directions
        for (int i = 0; i < 4; i++) {
            int newRow = row + directions[i][0];
            int newCol = col + directions[i][1];
            
            // Check bounds
            if (newRow < 0 || newRow >= rows || newCol < 0 || newCol >= cols) {
                continue;
            }
            
            char cell = grid[newRow][newCol];
            
            // Skip walls
            if (cell == '#') {
                continue;
            }
            
            // Skip locked doors without key
            if (cell >= 'A' && cell <= 'F' && !(keys & (1 << (cell - 'A')))) {
                continue;
            }
            
            // Calculate new key state
            int newKeys = keys;
            if (cell >= 'a' && cell <= 'f') {
                newKeys |= (1 << (cell - 'a'));
            }
            
            // Skip if we've seen this state before
            if (visited[newRow][newCol][newKeys]) {
                continue;
            }
            
            visited[newRow][newCol][newKeys] = true;
            enqueue(&queue, (struct State){newRow, newCol, newKeys, moves + 1});
        }
    }
    
    return -1;
}

int main() {
    char* grid[] = {"@.a.#","###.#","b.A.B"};
    int gridColSize[] = {5, 5, 5};
    printf("%d\n", shortestPathAllKeys(grid, 3, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*2^k)

We have m*n positions and 2^k possible key states (k ≤ 6), each state processed once

✓ Linear Growth

Space Complexity

O(m*n*2^k)

Need to store visited states and BFS queue, both bounded by total number of possible states

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 30
grid[i][j] is a lowercase letter, uppercase letter, '.', '#', or '@'
The number of keys is in the range [1, 6]
There is exactly one lowercase and one uppercase letter of the first k letters of the English alphabet in the grid
1 ≤ k ≤ 6

43.7K Views

High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS with State Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler