【leetcode刷题笔记】Word Ladder II

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

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

For example,

Given:
start = "hit"
end = "cog"
dict = ["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.

---

题解：算是leetcode最恶心的一道题了。

跟Word Ladder一样要用BFS来搜索，但是要解决的问题是如何在BFS中保存路径。我们知道在DFS中 保存路径十分简单，但是在BFS中就很麻烦了。因为我们把点一层一层的放在队列里面，而不是一次把一条路径搜索完全。所以这里引进一种新的类Node如下：

class Node{
        ArrayList<Node> prev;
        String me;
        int dist;
        public Node(String me,int dist){
            this.me = me;
            this.prev = null;
            this.dist = dist;
        }
    }

使用该类，我们把搜索路径上遇到的每一个单词看成一个节点，me保存该节点对应的单词，dist保存从start单词搜索到该单词的最短距离,prev保存从start到该节点所有长度为dist的路径上该节点的前驱节点。

这样我们就可以在完成BFS后，从最后一个节点endNode（endNode对应单词end），利用前驱节点信息DFS出startNode到endNode的所有路径了。函数findPath实现这个功能。

另外在BFS的时候，我们需要一个map，来记录当前访问过哪些单词以及它们对应的节点。假设当前访问的节点是node，它对应的单词是t，我们通过修改t的每一位字母生成新的单词，如果新的单词在dict中且没有建立相应的节点（在map中没有记录），那么就建立相应的节点，并把该节点和单词的对应信息保存在map里面；如果当前生成的单词在dict中且已经有相应的节点，那么我们就看是否node也是它的前驱，如果是，把node加入它的前驱列表就可以了。

结束的条件是，我们生成了一个单词，它正好等于end，说明找到了从start到end的一条路径（不过为了找到所有到end的路径，所以当前队列中的元素还是要遍历完，因为它们在同一层上，也有可能可以达到end，所以用一个stop变量控制最外层的大循环）；或者队列为空，说明找不到从start到end的路径。

最后代码如下：

 public class Solution {
 private List<List<String>> answer= new ArrayList<List<String>>();
     class Node{
         ArrayList<Node> prev;
         String me;
         int dist;
         public Node(String me,int dist){
             this.me = me;
             this.prev = null;
             this.dist = dist;
         }
     }
     private void findPath(Node endNode,ArrayList<String> result,String start){
         if(endNode.me.equals(start)){
             ArrayList<String> temp= new ArrayList<String>(result);
             answer.add(temp);
             return;
         }
         for(Node n:endNode.prev){
             result.add(0, n.me);
             findPath(n, result, start);
             result.remove(0);
         }
     }
     public List<List<String>> findLadders(String start, String end, Set<String> dict) {

         if(start == end){
             List<String> result = new ArrayList<String>();
             result.add(start);
             result.add(end);
             answer.add(result);
             return answer;
         }

         Queue<Node> queue = new LinkedList<Node>();
         HashMap<String, Node> map = new HashMap<String,Node>();

         Node startNdoe = new Node(start,0);
         queue.add(startNdoe);
         map.put(start, startNdoe);
         Node endNode = null;
         int strLen = start.length();
         boolean stop = false;

         while(!queue.isEmpty() && !stop){
             int thisLevel = queue.size();
             for(int i = 0;i < thisLevel;i++){
                 Node node = queue.poll();
                 for(int j = 0;j < strLen;j++){
                     StringBuilder t = new StringBuilder(node.me);
                     char ch_t = node.me.charAt(j);
                     for(char k = 'a';k <= 'z';k++){
                         if(k != ch_t){
                             t.setCharAt(j, k);
                             if(dict.contains(t.toString())){
                                 Node v = map.get(t.toString());
                                 if(v == null){
                                     Node tempNode = new Node(t.toString(),node.dist+1);
                                     tempNode.prev = new ArrayList<Node>();
                                     tempNode.prev.add(node);
                                     queue.add(tempNode);
                                     map.put(t.toString(), tempNode);
                                     if(t.toString().equals(end)){
                                         endNode = tempNode;
                                         stop = true;
                                     }
                                 }
                                 else {
                                     if(v.dist == node.dist+1)
                                         v.prev.add(node);
                                 }
                             }
                         }
                     }
                 }
             }
         }
         if(endNode != null){
             ArrayList<String> result = new ArrayList<String>();
             result.add(endNode.me);
             findPath(endNode,result,start);
         }
         return answer;
     }
 }