Word Ladder (Length of shortest chain to reach a target word)

Given a dictionary, and two words ‘start’ and ‘target’ (both of same length). Find length of the smallest chain from ‘start’ to ‘target’ if it exists, such that adjacent words in the chain only differ by one character and each word in the chain is a valid word i.e., it exists in the dictionary. It may be assumed that the ‘target’ word exists in dictionary and length of all dictionary words is same.


Input:  Dictionary = {POON, PLEE, SAME, POIE, PLEA, PLIE, POIN}
             start = TOON
             target = PLEA
Output: 7
Explanation: TOON - POON - POIN - POIE - PLIE - PLEE - PLEA

The idea is to use BFS. We start from the given start word, traverse all words that adjacent (differ by one character) to it and keep doing so until we find the target word or we have traversed all words.

Below is C++ implementation of above idea.






// C++ program to find length of the shortest chain
// transformation from source to target
#include <bits/stdc++.h>
using namespace std;
// Returns length of shortest chain to reach 'target' from 'start'
// using minimum number of adjacent moves.  D is dictionary
int shortestChainLen(string start, string target, set<string>& D)
    // If the target string is not
    // present in the dictionary
    if (D.find(target) == D.end())
        return 0;
    // To store the current chain length
    // and the length of the words
    int level = 0, wordlength = start.size();
    // Push the starting word into the queue
    queue<string> Q;
    // While the queue is non-empty
    while (!Q.empty()) {
        // Increment the chain length
        // Current size of the queue
        int sizeofQ = Q.size();
        // Since the queue is being updated while
        // it is being traversed so only the
        // elements which were already present
        // in the queue before the start of this
        // loop will be traversed for now
        for (int i = 0; i < sizeofQ; ++i) {
            // Remove the first word from the queue
            string word = Q.front();
            // For every character of the word
            for (int pos = 0; pos < wordlength; ++pos) {
                // Retain the original character
                // at the current position
                char orig_char = word[pos];
                // Replace the current character with
                // every possible lowercase alphabet
                for (char c = 'a'; c <= 'z'; ++c) {
                    word[pos] = c;
                    // If the new word is equal
                    // to the target word
                    if (word == target)
                        return level + 1;
                    // Remove the word from the set
                    // if it is found in it
                    if (D.find(word) == D.end())
                    // And push the newly generated word
                    // which will be a part of the chain
                // Restore the original character
                // at the current position
                word[pos] = orig_char;
    return 0;
// Driver program
int main()
    // make dictionary
    set<string> D;
    string start = "toon";
    string target = "plea";
    cout << "Length of shortest chain is: "
         << shortestChainLen(start, target, D);
    return 0;



Length of shortest chain is: 7

Time Complexity of the above code is O(n²m) where n is the number of entries originally in the dictionary and m is the size of the string

Thanks to Gaurav Ahirwar and Rajnish Kumar Jha for above solution.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes arrow_drop_up
Article Tags :
Practice Tags :


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.