Word Ladder Problem in Java

A well-known challenge in computer science is the word ladder problem, which entails changing one letter at a time to change one word into another. For instance, by altering the letters "cat" to "cot," "cot" to "dot," and lastly "dot," "dog," we may make the word "cat" into the word "dog." The objective of the word ladder puzzle is to identify the shortest string of words that can change one word into another.

We will go over the word ladder problem's Java implementation in this article. Before talking about the technique for determining the shortest word sequence, we will first explain the data structures that we will require.

Data Structures

The word ladder problem will require the following primary data structures:

To keep track of the terms we are using, we will utilise a collection of words. This will enable us to avoid using duplicate terms and to rapidly determine whether a word is legitimate.

Word queue: To keep track of the words we need to process, we'll utilise a word queue. Starting with the first word, we will add to the queue all of the words that can be obtained by changing one letter. Once the target word has been found, we shall go on processing words from the queue.

We will keep track of the words we have visited using a map. By doing so, we will be able to avoid having to look up previously used words and maintain a record of the order in which they were discovered.

Algorithm

The word ladder problem's algorithm is rather straightforward.

We'll begin by marking the first word as visited and adding it to the queue.
Then, we'll go into a loop where we go through the words in the queue one at a time until we locate the target word or the queue is empty.
All words that can be reached by changing one letter are added to the queue for each word that is processed, and they are then designated as visited.
Once we have located the target word, we may create the shortest word sequence using the map of words we have already visited.
Starting with the target word, we go through the list of words until we reach the first one.

The Java code for the word ladder issue is as follows:

WordLadder.java

import java.util.*;
public class WordLadder {
    public static List<String> ladder(String start, String end, Set<String> dict) {
        Queue<String> queue = new LinkedList<>();
        Map<String, String> visited = new HashMap<>();
        queue.offer(start);
        visited.put(start, null);
        while (!queue.isEmpty()) {
            String word = queue.poll();
            if (word.equals(end)) {
                break;
            }
            for (int i = 0; i < word.length(); i++) {
                char[] wordChars = word.toCharArray();
                for (char c = 'a'; c <= 'z'; c++) {
                    wordChars[i] = c;
                    String newWord = new String(wordChars);
                    if (dict.contains(newWord) && !visited.containsKey(newWord)) {
                        queue.offer(newWord);
                        visited.put(newWord, word);
                    }
                }
            }
        }
        List<String> ladder = new LinkedList<>();
        if (!visited.containsKey(end)) {
            return ladder;
        }
        String word = end;
        while (word != null) {
            ladder.add(0, word);
            word = visited.get(word);
        }
        return ladder;
    }
    public static void main(String[] args) {
        String start = "hit";
        String end = "cog";
        Set<String> dict = new HashSet<>();
        dict.add("hot");
        dict.add("dot");
        dict.add("dog");
        dict.add("lot");
        dict.add("log");
        List<String> ladder = ladder(start, end, dict);
        if (ladder.size() == 0) {
            System.out.println("No ladder found.");
        } else {
            System.out.println(ladder);
        }
    }
}

Output:

[hit, hot, dot, dog, cog]

Conclusion

In this article, we covered the Java implementation of the word ladder problem. We started by talking about the data structures we require before moving on to the process for determining the shortest word sequence. A common example of a classic computer science problem is the word ladder problem.

Next TopicVarious Operations on Queue in Java

← prev next →