Word Ladder 解答

Question

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the word list

For example,

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

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

• Return 0 if there is no such transformation sequence.
• All words have the same length.
• All words contain only lowercase alphabetic characters.

Solution 1 -- BFS

 class WordNode{
     String word;
     int numSteps;

     public WordNode(String word, int numSteps){
         this.word = word;
         this.numSteps = numSteps;
     }
 }

 public class Solution {
     public int ladderLength(String beginWord, String endWord, Set<String> wordList) {
         Queue<WordNode> queue = new LinkedList<WordNode>();
         queue.add(new WordNode(beginWord, 1));

         wordList.add(endWord);

         // 由于这里纪录了每个词的最小步数，所以不用两个list
         while (queue.size() > 0) {
             WordNode topNode = queue.remove();
             String current = topNode.word;

             if (current.equals(endWord))
                 return topNode.numSteps;

             char[] arr = current.toCharArray();
             // 穷举法
             for (int i = 0; i < arr.length; i++) {
                 for (char c = 'a'; c <= 'z'; c++) {
                     char tmp = arr[i];
                     if (arr[i] != c)
                         arr[i] = c;

                     String newWord = new String(arr);
                     if (wordList.contains(newWord)) {
                         queue.add(new WordNode(newWord, topNode.numSteps + 1));
                         wordList.remove(newWord);
                     }
                     arr[i] = tmp;
                 }
             }
         }
         return 0;
     }
 }

Solution 2 -- BFS & Adjacency List

Basic idea is: 1. construct adjacency list 2. BFS

Constructing adjacency list uses O(n²) time, and BFS is O(n). Total time complexity is O(n²), when testing in leetcode, it reports "time limit exceeded".

 public class Solution {
     public int ladderLength(String beginWord, String endWord, Set<String> wordList) {
         if (wordList == null)
             return -1;
         int step = 1;
         if (beginWord.equals(endWord))
             return 1;
         // Construct adjacency lists for words
         // Do not forget start word and end word
         wordList.add(beginWord);
         wordList.add(endWord);
         Map<String, List<String>> adjacencyList = new HashMap<String, List<String>>();
         Map<String, Boolean> visited = new HashMap<String, Boolean>();
         int length = wordList.size();
         String[] wordList2 = new String[length];
         int i = 0;
         for (String current : wordList) {
             wordList2[i] = current;
             i++;
         }
         // Initialization
         for (i = 0; i < length; i++) {
             adjacencyList.put(wordList2[i], new ArrayList<String>());
             visited.put(wordList2[i], false);
         }

         for (i = 0; i < length; i++) {
             String current = wordList2[i];
             // Construct adjacency list for each element
             for (int j = i + 1; j < length; j++) {
                 String next = wordList2[j];
                 if (isAdjacent(current, next)) {
                     List<String> list1 = adjacencyList.get(current);
                     list1.add(next);
                     adjacencyList.put(current, list1);
                     List<String> list2 = adjacencyList.get(next);
                     list2.add(current);
                     adjacencyList.put(next, list2);
                 }
             }
         }

         // BFS
         List<String> current = new ArrayList<String>();
         List<String> next;
         current.add(beginWord);
         visited.put(beginWord, true);
         while (current.size() > 0) {
             step++;
             next = new ArrayList<String>();
             for (String currentString : current) {
                 List<String> neighbors = adjacencyList.get(currentString);
                 if (neighbors == null)
                     continue;
                 for (String neighbor : neighbors) {
                     if (neighbor.equals(endWord))
                         return step;
                     if (!visited.get(neighbor)) {
                         next.add(neighbor);
                         visited.put(neighbor, true);
                     }
                 }
             }
             current = next;
         }
         return -1;

     }

     private boolean isAdjacent(String current, String next) {
         if (current.length() != next.length())
             return false;
         int length = current.length();
         int diff = 0;
         for (int i = 0; i < length; i++) {
             char a = current.charAt(i);
             char b = next.charAt(i);
             if (a != b)
                 diff++;
         }
         if (diff == 1)
             return true;
         return  false;
     }
 }

Python version

 from collections import deque
 from collections import defaultdict

 class Solution:
     def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
         if endWord not in wordList:
             return 0
         queue = deque()
         queue.append((beginWord, 1))
         visited = set([beginWord])
         adjacency_map = defaultdict(list)
         L = len(beginWord)
         # Pre-process
         for word in wordList:
             for i in range(L):
                 adjacency_map[word[:i] + "*" + word[i+1:]].append(word)
         # BFS
         while queue:
             curr_word, curr_steps = queue.popleft()
             if curr_word == endWord:
                 return curr_steps
             # List all possibilities
             for i in range(L):
                 key = curr_word[:i] + "*" + curr_word[i+1:]
                 if key in adjacency_map:
                     neighbors = adjacency_map[key]
                     for neighbor in neighbors:
                         if neighbor == endWord:
                             return curr_steps + 1
                         if neighbor not in visited:
                             queue.append((neighbor, curr_steps + 1))
                             visited.add(neighbor)
                     adjacency_map[key] = {}
         return 0