Word Ladder II

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.

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

Visualization

Tap to expand

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

✓ BFS + Backtracking (Standard Approach)

⏱️ Time: O(N * 26 * L + B^D) Space: O(N * L)

This is the standard two-phase approach: First, use BFS to find the shortest distance from beginWord to all reachable words. Then, use backtracking to reconstruct all paths that follow edges leading to words with decreasing distances to the target.

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>

#define MAX_WORDS 5000
#define MAX_PATHS 1000
#define MAX_PATTERNS 10000

static char all_words[MAX_WORDS][12];
static int all_words_size = 0;

typedef struct PatternNode {
    char pattern[12];
    char words[100][12];
    int word_count;
    struct PatternNode* next;
} PatternNode;

typedef struct {
    PatternNode* buckets[MAX_PATTERNS];
} PatternMap;

typedef struct {
    char words[MAX_WORDS][12];
    int front, rear;
} Queue;

typedef struct {
    char word[12];
    int distance;
} DistanceEntry;

typedef struct {
    DistanceEntry entries[MAX_WORDS];
    int size;
} DistanceMap;

static PatternMap neighbors;
static DistanceMap distances;
static Queue queue;
static char*** global_result;
static int* global_returnColumnSizes;
static int global_result_size;
static char visited_words[MAX_WORDS][12];
static int visited_count;

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % MAX_PATTERNS;
}

PatternNode* find_pattern(PatternMap* map, const char* pattern) {
    unsigned int h = hash(pattern);
    PatternNode* node = map->buckets[h];
    while (node) {
        if (strcmp(node->pattern, pattern) == 0) {
            return node;
        }
        node = node->next;
    }
    return NULL;
}

void add_to_pattern(PatternMap* map, const char* pattern, const char* word) {
    PatternNode* node = find_pattern(map, pattern);
    if (!node) {
        node = (PatternNode*)malloc(sizeof(PatternNode));
        strcpy(node->pattern, pattern);
        node->word_count = 0;
        unsigned int h = hash(pattern);
        node->next = map->buckets[h];
        map->buckets[h] = node;
    }
    strcpy(node->words[node->word_count], word);
    node->word_count++;
}

int find_in_distance_map(DistanceMap* map, const char* word) {
    for (int i = 0; i < map->size; i++) {
        if (strcmp(map->entries[i].word, word) == 0) {
            return map->entries[i].distance;
        }
    }
    return -1;
}

void add_to_distance_map(DistanceMap* map, const char* word, int distance) {
    strcpy(map->entries[map->size].word, word);
    map->entries[map->size].distance = distance;
    map->size++;
}

int find_in_next_distances(DistanceEntry* next_distances, int size, const char* word) {
    for (int i = 0; i < size; i++) {
        if (strcmp(next_distances[i].word, word) == 0) {
            return next_distances[i].distance;
        }
    }
    return -1;
}

int is_visited(const char* word) {
    for (int i = 0; i < visited_count; i++) {
        if (strcmp(visited_words[i], word) == 0) {
            return 1;
        }
    }
    return 0;
}

void add_visited(const char* word) {
    strcpy(visited_words[visited_count], word);
    visited_count++;
}

void remove_visited() {
    visited_count--;
}

void get_neighbors(const char* word, char neighbors_list[][12], int* count) {
    *count = 0;
    char processed[MAX_WORDS][12];
    int processed_count = 0;
    
    int word_len = strlen(word);
    for (int i = 0; i < word_len; i++) {
        char pattern[12];
        strncpy(pattern, word, i);
        pattern[i] = '*';
        strcpy(pattern + i + 1, word + i + 1);
        
        PatternNode* node = find_pattern(&neighbors, pattern);
        if (node) {
            for (int j = 0; j < node->word_count; j++) {
                const char* neighbor = node->words[j];
                if (strcmp(neighbor, word) == 0) {
                    continue;
                }
                
                int already_processed = 0;
                for (int k = 0; k < processed_count; k++) {
                    if (strcmp(processed[k], neighbor) == 0) {
                        already_processed = 1;
                        break;
                    }
                }
                
                if (!already_processed) {
                    int neighbor_dist = find_in_distance_map(&distances, neighbor);
                    int word_dist = find_in_distance_map(&distances, word);
                    if (neighbor_dist != -1 && neighbor_dist == word_dist - 1 && !is_visited(neighbor)) {
                        strcpy(neighbors_list[*count], neighbor);
                        (*count)++;
                        strcpy(processed[processed_count], neighbor);
                        processed_count++;
                    }
                }
            }
        }
    }
}

void backtrack(const char* word, const char* beginWord, char path[][12], int path_len) {
    if (strcmp(word, beginWord) == 0) {
        global_result[global_result_size] = (char**)malloc(path_len * sizeof(char*));
        global_returnColumnSizes[global_result_size] = path_len;
        
        for (int i = 0; i < path_len; i++) {
            global_result[global_result_size][i] = (char*)malloc(12);
            strcpy(global_result[global_result_size][i], path[path_len - 1 - i]);
        }
        global_result_size++;
        return;
    }
    
    char neighbors_list[MAX_WORDS][12];
    int neighbor_count;
    get_neighbors(word, neighbors_list, &neighbor_count);
    
    for (int i = 0; i < neighbor_count; i++) {
        const char* neighbor = neighbors_list[i];
        strcpy(path[path_len], neighbor);
        add_visited(neighbor);
        backtrack(neighbor, beginWord, path, path_len + 1);
        remove_visited();
    }
}

char*** findLadders(char* beginWord, char* endWord, char** wordList,
                    int wordListSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    
    memset(&neighbors, 0, sizeof(PatternMap));
    distances.size = 0;
    queue.front = 0;
    queue.rear = 0;
    all_words_size = 0;
    visited_count = 0;
    
    int end_found = 0;
    for (int i = 0; i < wordListSize; i++) {
        if (strcmp(wordList[i], endWord) == 0) {
            end_found = 1;
            break;
        }
    }
    if (!end_found) {
        *returnColumnSizes = (int*)malloc(sizeof(int));
        char*** result = (char***)malloc(sizeof(char**));
        return result;
    }
    
    for (int i = 0; i < wordListSize; i++) {
        strcpy(all_words[all_words_size], wordList[i]);
        all_words_size++;
    }
    strcpy(all_words[all_words_size], beginWord);
    all_words_size++;
    
    for (int w = 0; w < all_words_size; w++) {
        const char* word = all_words[w];
        int word_len = strlen(word);
        for (int i = 0; i < word_len; i++) {
            char pattern[12];
            strncpy(pattern, word, i);
            pattern[i] = '*';
            strcpy(pattern + i + 1, word + i + 1);
            add_to_pattern(&neighbors, pattern, word);
        }
    }
    
    add_to_distance_map(&distances, beginWord, 0);
    strcpy(queue.words[queue.rear], beginWord);
    queue.rear++;
    
    int found = 0;
    
    while (queue.front < queue.rear && !found) {
        int level_size = queue.rear - queue.front;
        DistanceEntry next_distances[MAX_WORDS];
        int next_size = 0;
        
        for (int k = 0; k < level_size; k++) {
            char* word = queue.words[queue.front];
            queue.front++;
            int word_dist = find_in_distance_map(&distances, word);
            
            int word_len = strlen(word);
            for (int i = 0; i < word_len; i++) {
                char pattern[12];
                strncpy(pattern, word, i);
                pattern[i] = '*';
                strcpy(pattern + i + 1, word + i + 1);
                
                PatternNode* node = find_pattern(&neighbors, pattern);
                if (node) {
                    for (int j = 0; j < node->word_count; j++) {
                        const char* neighbor = node->words[j];
                        if (strcmp(neighbor, word) == 0) {
                            continue;
                        }
                        if (strcmp(neighbor, endWord) == 0) {
                            found = 1;
                        }
                        if (find_in_distance_map(&distances, neighbor) == -1 &&
                            find_in_next_distances(next_distances, next_size, neighbor) == -1) {
                            strcpy(next_distances[next_size].word, neighbor);
                            next_distances[next_size].distance = word_dist + 1;
                            next_size++;
                        }
                    }
                }
            }
        }
        
        for (int i = 0; i < next_size; i++) {
            add_to_distance_map(&distances, next_distances[i].word, next_distances[i].distance);
            strcpy(queue.words[queue.rear], next_distances[i].word);
            queue.rear++;
        }
    }
    
    char*** result = (char***)malloc(MAX_PATHS * sizeof(char**));
    *returnColumnSizes = (int*)malloc(MAX_PATHS * sizeof(int));
    
    global_result = result;
    global_returnColumnSizes = *returnColumnSizes;
    global_result_size = 0;
    
    if (find_in_distance_map(&distances, endWord) != -1) {
        char path[100][12];
        strcpy(path[0], endWord);
        add_visited(endWord);
        backtrack(endWord, beginWord, path, 1);
    }
    
    *returnSize = global_result_size;
    
    return result;
}

void parseWordList(char* str, char** wordList, int* size) {
    *size = 0;
    char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p && (*p == ' ' || *p == ',' || *p == '\t')) p++;
        if (*p == ']' || !*p) break;
        
        if (*p == '"') {
            p++;
            char* start = p;
            while (*p && *p != '"') p++;
            int len = p - start;
            wordList[*size] = (char*)malloc(len + 1);
            strncpy(wordList[*size], start, len);
            wordList[*size][len] = '\0';
            (*size)++;
            if (*p == '"') p++;
        } else {
            p++;
        }
    }
}

int main() {
    char beginWord[100];
    char endWord[100];
    char wordListStr[10000];
    
    if (fgets(beginWord, sizeof(beginWord), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    beginWord[strcspn(beginWord, "\n\r")] = '\0';
    
    if (fgets(endWord, sizeof(endWord), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    endWord[strcspn(endWord, "\n\r")] = '\0';
    
    if (fgets(wordListStr, sizeof(wordListStr), stdin) == NULL) {
        printf("[]\n");
        return 0;
    }
    wordListStr[strcspn(wordListStr, "\n\r")] = '\0';
    
    char** wordList = (char**)malloc(MAX_WORDS * sizeof(char*));
    int wordListSize = 0;
    
    parseWordList(wordListStr, wordList, &wordListSize);
    
    int returnSize;
    int* returnColumnSizes;
    char*** result = findLadders(beginWord, endWord, wordList, wordListSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("\"%s\"", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < wordListSize; i++) {
        free(wordList[i]);
    }
    free(wordList);
    
    return 0;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

BFS + Backtracking (Standard Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler