Word Ladder - Practice Coding Problems

Word Ladder - Problem

Word Ladder is a classic transformation puzzle where you need to find the shortest path from one word to another by changing exactly one letter at a time.

Given a beginWord, an endWord, and a dictionary wordList, you need to find the minimum number of words in the transformation sequence from beginWord to endWord. Each intermediate word must be in the dictionary, and each step can only change one letter.

Example: Transform "hit" → "cog" using dictionary ["hot","dot","dog","lot","log","cog"]
Path: "hit" → "hot" → "dot" → "dog" → "cog" = 5 words

Return 0 if no transformation sequence exists.

Input & Output

example_1.py — Basic Transformation

$ Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]

› Output: 5

💡 Note: One shortest transformation sequence is "hit" → "hot" → "dot" → "dog" → "cog", which has 5 words.

example_2.py — No Path Exists

$ Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]

› Output: 0

💡 Note: The endWord "cog" is not in wordList, so no transformation sequence is possible.

example_3.py — Direct Transformation

$ Input: beginWord = "a", endWord = "c", wordList = ["a","b","c"]

› Output: 2

💡 Note: The shortest transformation sequence is "a" → "c" with 2 words.

Visualization

Tap to expand

Understanding the Visualization

Initial Ripple

Start with beginWord as the center point (level 1)

First Wave

Explore all words reachable in 1 transformation (level 2)

Expanding Waves

Continue expanding to words reachable in 2, 3, 4... transformations

Target Reached

The first wave to touch endWord gives us the shortest path

Key Takeaway

🎯 Key Insight: BFS is perfect for shortest path problems in unweighted graphs because it explores nodes level by level, ensuring the first time we reach our destination is via the shortest route.

Time & Space Complexity

Time Complexity

⏱️

O(M×N×26)

M words in wordList, N length of each word, 26 letters to try for each position

✓ Linear Growth

Space Complexity

O(M)

Queue storage and visited set, both bounded by number of words

✓ Linear Space

Constraints

1 ≤ beginWord.length ≤ 10
endWord.length == beginWord.length
1 ≤ wordList.length ≤ 5000
wordList[i].length == beginWord.length
All strings contain only lowercase English letters
All the strings in wordList are unique
beginWord ≠ endWord

Asked in

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

The optimal solution uses Breadth-First Search (BFS) to find the shortest transformation path. BFS explores all words at distance 1, then distance 2, guaranteeing the first path found is the shortest. Key optimizations include using a hash set for O(1) word lookups and tracking visited words to avoid cycles. Time complexity: O(M×N×26) where M is wordList size and N is word length.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Queue (Optimal)	O(M×N×26)	O(M)	Use BFS to find shortest transformation path in minimum time
Brute Force (DFS with All Paths)	O(M^N)	O(M)	Explore all possible transformation paths using recursive DFS

BFS with Queue (Optimal) — Algorithm Steps

Initialize queue with beginWord and level 1
Convert wordList to hash set for O(1) lookups
For each word in queue, try all single-letter transformations
If transformation equals endWord, return current level + 1
If transformation exists in wordList and not visited, add to queue
Continue BFS until queue is empty or target found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 1

Start with 'hit', explore all 1-step transformations

Level 2

From 'hot', explore all 2-step transformations

Level 3

From 'dot', 'lot', explore 3-step transformations

Target Found

Reach 'cog' at level 5 - shortest path found!

Code -

solution.c — C

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

typedef struct QueueNode {
    char* word;
    int level;
    struct QueueNode* next;
} QueueNode;

typedef struct {
    QueueNode* front;
    QueueNode* rear;
} Queue;

void enqueue(Queue* q, char* word, int level) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->word = strdup(word);
    newNode->level = level;
    newNode->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

QueueNode* dequeue(Queue* q) {
    if (q->front == NULL) return NULL;
    
    QueueNode* temp = q->front;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    return temp;
}

bool containsWord(char** wordList, int size, char* word) {
    for (int i = 0; i < size; i++) {
        if (strcmp(wordList[i], word) == 0) return true;
    }
    return false;
}

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

int ladderLength(char* beginWord, char* endWord, char** wordList, int wordListSize) {
    if (!containsWord(wordList, wordListSize, endWord)) return 0;
    
    Queue q = {NULL, NULL};
    char** visited = (char**)malloc(1000 * sizeof(char*));
    int visitedSize = 0;
    
    enqueue(&q, beginWord, 1);
    visited[visitedSize++] = strdup(beginWord);
    
    while (q.front != NULL) {
        QueueNode* current = dequeue(&q);
        int wordLen = strlen(current->word);
        char* newWord = (char*)malloc((wordLen + 1) * sizeof(char));
        
        for (int i = 0; i < wordLen; i++) {
            strcpy(newWord, current->word);
            
            for (char c = 'a'; c <= 'z'; c++) {
                if (c != current->word[i]) {
                    newWord[i] = c;
                    
                    if (strcmp(newWord, endWord) == 0) {
                        free(newWord);
                        free(current->word);
                        free(current);
                        return current->level + 1;
                    }
                    
                    if (containsWord(wordList, wordListSize, newWord) && 
                        !isVisited(visited, visitedSize, newWord)) {
                        visited[visitedSize++] = strdup(newWord);
                        enqueue(&q, newWord, current->level + 1);
                    }
                }
            }
        }
        
        free(newWord);
        free(current->word);
        free(current);
    }
    
    // Cleanup
    for (int i = 0; i < visitedSize; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(M×N×26)

M words in wordList, N length of each word, 26 letters to try for each position

✓ Linear Growth

Space Complexity

O(M)

Queue storage and visited set, both bounded by number of words

✓ Linear Space

Constraints

1 ≤ beginWord.length ≤ 10
endWord.length == beginWord.length
1 ≤ wordList.length ≤ 5000
wordList[i].length == beginWord.length
All strings contain only lowercase English letters
All the strings in wordList are unique
beginWord ≠ endWord

267.7K Views

High Frequency

~25 min Avg. Time

8.9K 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 Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler