Word Ladder II - Practice Coding Problems

Word Ladder II - Problem

Imagine you're a linguist working with word transformations! You need to find all the shortest possible paths to transform one word into another by changing exactly one letter at a time.

Given a beginWord, an endWord, and a dictionary of valid words (wordList), your task is to return all the shortest transformation sequences from beginWord to endWord.

Rules for transformation:

Each step changes exactly one letter
Every intermediate word must exist in the wordList
The beginWord doesn't need to be in wordList
All words have the same length and contain only lowercase letters

Example: Transform "hit" → "cog"
Possible path: ["hit", "hot", "dot", "dog", "cog"]
Another path: ["hit", "hot", "lot", "log", "cog"]

Return an empty list if no transformation sequence exists. If multiple shortest paths exist, return all of them!

Input & Output

example_1.py — Basic Transformation

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

› Output: [["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]

💡 Note: There are 2 shortest transformation sequences of length 5. Both start with 'hit'→'hot', then diverge: one goes through 'dot'→'dog' and the other through 'lot'→'log', both ending at 'cog'.

example_2.py — No Valid Path

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

› Output: []

💡 Note: The endWord 'cog' is not in the wordList, so no transformation sequence is possible. We cannot transform to a word that doesn't exist in our dictionary.

example_3.py — Single Step

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

› Output: [["a","c"]]

💡 Note: Direct transformation from 'a' to 'c' in one step (changing one letter). This is the shortest possible path with length 2.

Visualization

Tap to expand

Understanding the Visualization

Build Word Graph

Create connections between words that differ by exactly one letter

BFS for Distances

Use BFS to find shortest distance from start word to all reachable words

Backtrack Paths

From end word, follow only edges leading to words closer to start

Collect Results

All valid backtracking paths give us the shortest transformation sequences

Key Takeaway

🎯 Key Insight: Use BFS to find shortest distances first, then backtrack following only edges that decrease distance by 1. This ensures we find ALL shortest paths efficiently without exploring suboptimal routes.

Time & Space Complexity

Time Complexity

⏱️

O(N * 26 * L + B^D)

N words × 26 letters × L length for BFS, plus B^D for backtracking where B is branching factor and D is depth

✓ Linear Growth

Space Complexity

O(N * L)

Space for neighbor graph, distance map, and recursion stack

✓ Linear Space

Constraints

1 ≤ beginWord.length ≤ 10
endWord.length == beginWord.length
1 ≤ wordList.length ≤ 5000
wordList[i].length == beginWord.length
beginWord, endWord, and wordList[i] consist of lowercase English letters
beginWord ≠ endWord
All the words in wordList are unique

Asked in

A Amazon 45 G Google 38 f Meta 31 ⊞ Microsoft 27 🍎 Apple 22

The optimal approach uses BFS + Backtracking: First, run BFS from beginWord to find the shortest distance to all reachable words. Then, use backtracking from endWord, only following edges that lead to words with distance = current_distance - 1. This guarantees we only construct shortest paths while finding all possible ones. Time complexity: O(N × 26 × L + B^D) where N is word count, L is word length, B is branching factor, and D is shortest path depth.

Common Approaches

Approach	Time	Space	Notes
✓ BFS + Backtracking (Standard Approach)	O(N * 26 * L + B^D)	O(N * L)	Use BFS to find shortest distances, then backtrack to reconstruct all shortest paths

BFS + Backtracking (Standard Approach) — Algorithm Steps

Use BFS to calculate shortest distance from beginWord to all words
Build a graph of neighbors (words differing by one letter)
Use backtracking starting from endWord
Only follow edges that lead to words closer to beginWord
Collect all valid paths that reach beginWord
Reverse paths since we built them backwards

Visualization

Tap to expand

Step-by-Step Walkthrough

BFS Phase

Find shortest distance to all words from start

Build Distance Map

Store minimum steps to reach each word

Backtrack Phase

Follow edges that decrease distance to find all shortest paths

Code -

solution.c — C

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

#define MAX_WORDS 5000
#define MAX_PATHS 1000

typedef struct {
    char** words;
    int count;
} WordList;

typedef struct {
    char word[10];
    int distance;
} WordDistance;

int findWordIndex(char** wordList, int size, char* word) {
    for (int i = 0; i < size; i++) {
        if (strcmp(wordList[i], word) == 0) {
            return i;
        }
    }
    return -1;
}

int isOneLetterDiff(char* word1, char* word2) {
    int diff = 0;
    int len = strlen(word1);
    for (int i = 0; i < len; i++) {
        if (word1[i] != word2[i]) {
            diff++;
            if (diff > 1) return 0;
        }
    }
    return diff == 1;
}

void backtrack(char* word, char* beginWord, char** wordList, int wordListSize,
               int* distances, char** path, int pathLen, char*** result,
               int* resultSize, int** returnColumnSizes) {
    if (strcmp(word, beginWord) == 0) {
        result[*resultSize] = (char**)malloc((pathLen + 1) * sizeof(char*));
        (*returnColumnSizes)[*resultSize] = pathLen + 1;
        
        result[*resultSize][0] = (char*)malloc(strlen(beginWord) + 1);
        strcpy(result[*resultSize][0], beginWord);
        
        for (int i = 0; i < pathLen; i++) {
            result[*resultSize][i + 1] = (char*)malloc(strlen(path[pathLen - 1 - i]) + 1);
            strcpy(result[*resultSize][i + 1], path[pathLen - 1 - i]);
        }
        (*resultSize)++;
        return;
    }
    
    int currentWordIdx = findWordIndex(wordList, wordListSize, word);
    if (currentWordIdx == -1) return;
    
    for (int i = 0; i < wordListSize; i++) {
        if (distances[i] != -1 && distances[i] == distances[currentWordIdx] - 1 &&
            isOneLetterDiff(word, wordList[i])) {
            path[pathLen] = wordList[i];
            backtrack(wordList[i], beginWord, wordList, wordListSize, distances,
                     path, pathLen + 1, result, resultSize, returnColumnSizes);
        }
    }
}

char*** findLadders(char* beginWord, char* endWord, char** wordList,
                    int wordListSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    
    int endWordIdx = findWordIndex(wordList, wordListSize, endWord);
    if (endWordIdx == -1) return NULL;
    
    // BFS to find distances
    int* distances = (int*)malloc(wordListSize * sizeof(int));
    for (int i = 0; i < wordListSize; i++) {
        distances[i] = -1;
    }
    
    char** queue = (char**)malloc(wordListSize * sizeof(char*));
    int* queueDistances = (int*)malloc(wordListSize * sizeof(int));
    int front = 0, rear = 0;
    
    // Add beginWord neighbors to queue
    for (int i = 0; i < wordListSize; i++) {
        if (isOneLetterDiff(beginWord, wordList[i])) {
            queue[rear] = wordList[i];
            queueDistances[rear] = 1;
            distances[i] = 1;
            rear++;
        }
    }
    
    int found = 0;
    while (front < rear && !found) {
        int levelSize = rear - front;
        for (int level = 0; level < levelSize; level++) {
            char* currentWord = queue[front];
            int currentDist = queueDistances[front];
            front++;
            
            if (strcmp(currentWord, endWord) == 0) {
                found = 1;
                continue;
            }
            
            for (int i = 0; i < wordListSize; i++) {
                if (distances[i] == -1 && isOneLetterDiff(currentWord, wordList[i])) {
                    queue[rear] = wordList[i];
                    queueDistances[rear] = currentDist + 1;
                    distances[i] = currentDist + 1;
                    rear++;
                }
            }
        }
    }
    
    if (!found) {
        free(distances);
        free(queue);
        free(queueDistances);
        return NULL;
    }
    
    // Backtrack to find all paths
    char*** result = (char***)malloc(MAX_PATHS * sizeof(char**));
    *returnColumnSizes = (int*)malloc(MAX_PATHS * sizeof(int));
    char** path = (char**)malloc(100 * sizeof(char*));
    
    backtrack(endWord, beginWord, wordList, wordListSize, distances,
              path, 0, result, returnSize, returnColumnSizes);
    
    free(distances);
    free(queue);
    free(queueDistances);
    free(path);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N * 26 * L + B^D)

N words × 26 letters × L length for BFS, plus B^D for backtracking where B is branching factor and D is depth

✓ Linear Growth

Space Complexity

O(N * L)

Space for neighbor graph, distance map, and recursion stack

✓ Linear Space

Constraints

1 ≤ beginWord.length ≤ 10
endWord.length == beginWord.length
1 ≤ wordList.length ≤ 5000
wordList[i].length == beginWord.length
beginWord, endWord, and wordList[i] consist of lowercase English letters
beginWord ≠ endWord
All the words in wordList are unique

128.9K Views

Medium Frequency

~28 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS + Backtracking (Standard Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler