What is the time complexity of Word Ladder?

Time complexity: O(M² N) where M is word length, N is wordList size. Space complexity: O(M N).

What are common mistakes on Word Ladder?

Building the adjacency list in one direction on an undirected graph. Assuming the graph is connected. Most inputs allow several components, and one traversal from node 0 misses the rest. Ignoring self-loops and parallel edges when the constraints allow them.

gitGood.dev

← Back to problems

Word Ladder

HardData Structures

Description

A **transformation sequence** from word `beginWord` to word `endWord` using a dictionary `wordList` is a sequence of words `beginWord -> s1 -> s2 -> ... -> sk` such that: - Every adjacent pair of words differs by a single letter. - Every `si` for `1 <= i <= k` is in `wordList`. Note that `beginWord` does not need to be in `wordList`. - `sk == endWord` Given two words, `beginWord` and `endWord`, and a dictionary `wordList`, return the **number of words** in the **shortest transformation sequence** from `beginWord` to `endWord`, or `0` if no such sequence exists.

Example 1

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

Output: 5

Explanation: One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> "cog", which is 5 words long.

Example 2

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

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.

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.

Word Ladder: approach, complexity and pitfalls

A hard graphs problem, graded against 5 test cases (2 of them hidden).

The pattern: Graphs

Nodes and edges - traversal, connectivity, cycles, and shortest paths.

Reach for it when you see: Explicit edges, a grid treated as a graph, or dependencies between items.

More Graphsproblems →

If you are stuck

Show the 3-step hint ladder

Use BFS to find the shortest path.
For each word, generate all possible one-letter transformations.
Use a set for O(1) lookup of valid words.

The optimal approach

Show the approach: BFS

Treat it as a graph problem where each word is a node, and edges connect words that differ by one letter. Use BFS to find the shortest path.

Time: O(M² * N) where M is word length, N is wordList size
Space: O(M * N)

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

Common Graphs mistakes

These apply to the pattern as a whole, not just this problem.

Building the adjacency list in one direction on an undirected graph.
Assuming the graph is connected. Most inputs allow several components, and one traversal from node 0 misses the rest.
Ignoring self-loops and parallel edges when the constraints allow them.