Word Ladder II 解答

Question

Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) 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"]

Return

  [
    ["hit","hot","dot","dog","cog"],
    ["hit","hot","lot","log","cog"]
  ]

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.

Solution

Two major diffrences compared with "Word Ladder"

1. We should record path, i.e previous nodes

2. Only when stepNums changes can we remove this node from wordDict

注意的点有三个：

1. Queue中的数据结构

2. 什么时候判断不再遍历这个点？

当这个点已经在之前的层中被遍历（即当前步数大于之前的步数）=>需要一个Map来记录最少的步数

3. 什么时候判断不再遍历最后值为end的点？=>设置一个变量，记录第一个遍历到end值的步数。之后再遍历到end值，步数要与其比较。

 class WordNode {
     public String word;
     public WordNode prev;
     public int level;
     public WordNode (String word, WordNode prev, int level) {
         this.word = word;
         this.prev = prev;
         this.level = level;
     }
 }

 public class Solution {
     /**
       * @param start, a string
       * @param end, a string
       * @param dict, a set of string
       * @return a list of lists of string
       */
     public List<List<String>> findLadders(String start, String end, Set<String> dict) {
         // write your code here
         List<List<String>> result = new ArrayList<>();
         if (dict == null) {
             return result;
         }
         dict.add(start);
         dict.add(end);
         // get adjacent list
         Map<String, Set<String>> adjacentList = getNeighbors(dict);
         Map<String, Integer> visited = new HashMap<>();
         int prevLevel = 0;
         Queue<WordNode> queue = new ArrayDeque<>();
         queue.offer(new WordNode(start, null, 1));
         // bfs
         while (!queue.isEmpty()) {
             WordNode cur = queue.poll();
             if (end.equals(cur.word)) {
                 if (prevLevel == 0 || cur.level == prevLevel) {
                     prevLevel = cur.level;
                     addRecordToResult(result, cur);
                 } else {
                     break;
                 }
             } else {
                 Set<String> neighbors = adjacentList.get(cur.word);
                 if (neighbors == null || neighbors.size() == 0) {
                     continue;
                 }
                 Set<String> removeSet = new HashSet<>();
                 for (String str : neighbors) {
                     if (visited.containsKey(str)) {
                         int visitedLevel = visited.get(str);
                         if (cur.level + 1 > visitedLevel) {
                             removeSet.add(str);
                             continue;
                         }
                     }
                     visited.put(str, cur.level + 1);
                     queue.offer(new WordNode(str, cur, cur.level + 1));
                 }
                 neighbors.removeAll(removeSet);
             }
         }
         return result;
     }

     private Map<String, Set<String>> getNeighbors(Set<String> dict) {
         Map<String, Set<String>> map = new HashMap<>();
         for (String str : dict) {
             map.put(str, new HashSet<String>());
             char[] arr = str.toCharArray();
             int len = arr.length;
             for (int i = 0; i < len; i++) {
                 char prev = arr[i];
                 for (char j = 'a'; j <= 'z'; j++) {
                     if (prev == j) {
                         continue;
                     }
                     arr[i] = j;
                     String newStr = new String(arr);
                     if (dict.contains(newStr)) {
                         map.get(str).add(newStr);
                     }
                 }
                 arr[i] = prev;
             }
         }
         return map;
     }

     private void addRecordToResult(List<List<String>> result, WordNode end) {
         List<String> record = new ArrayList<>();
         while (end != null) {
             record.add(end.word);
             end = end.prev;
         }
         Collections.reverse(record);
         result.add(record);
     }
 }