Word Ladder II Graph

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.

The solution contains two steps 1 Use BFS to construct a graph. 2. Use DFS to construct the paths from end to start.Both solutions got AC within 1s.

The first step BFS is quite important. I summarized three tricks

1) Using a MAP to store the min ladder of each word, or use a SET to store the words visited in current ladder, when the current ladder was completed, delete the visited words from unvisited. That's why I have two similar solutions.

2) Use Character iteration to find all possible paths. Do not compare one word to all the other words and check if they only differ by one character.

3) One word is allowed to be inserted into the queue only ONCE. See my comments.

The idea is to use bfs build the graph level by level, use Map<String,Set> to store the parents of string, then use dfs to find the path.

 public class Solution {
     List<List<String>> result;
     HashMap<String, Set<String>> wordGraph;
     public List<List<String>> findLadders(String start, String end, Set<String> dict) {
         result = new ArrayList<List<String>>();
         if(dict == null || dict.size() == 0) return result;
         wordGraph = new HashMap<String, Set<String>>();
         wordGraph.put(start, new HashSet<String>());
         LinkedList<String> queue = new LinkedList<String>();
         HashSet<String> used = new HashSet<String>();
         queue.add(start);
         queue.add(null);
         boolean flg = false;
         while(queue.size() != 1){
             String cur = queue.poll();
             used.add(cur);
             if(cur == null){
                 if(flg == true) break;
                 else queue.add(null);
             }else{
                 char[] arr = cur.toCharArray();
                 for(int i = 0; i < cur.length(); i ++){
                     for(char j = 'a'; j <= 'z'; j ++){
                         if(arr[i] == j) continue;
                         char tmp = arr[i];
                         arr[i] = j;
                         String tmpString = String.valueOf(arr);
                         if(end.equals(tmpString)){
                             flg = true;
                             if(!wordGraph.containsKey(tmpString)){
                                 Set<String> parents = new HashSet<String>();
                                 parents.add(cur);
                                 wordGraph.put(tmpString, parents);
                             }else{
                                 wordGraph.get(tmpString).add(cur);
                             }
                         }else if(dict.contains(tmpString) && !used.contains(tmpString) && flg != true){
                             if(!wordGraph.containsKey(tmpString)){
                                 Set<String> parents = new HashSet<String>();
                                 parents.add(cur);
                                 wordGraph.put(tmpString, parents);
                             }else{
                                 wordGraph.get(tmpString).add(cur);
                             }
                             queue.add(tmpString);

                         }
                         arr[i] = tmp;
                     }
                 }
             }
         }
         if(wordGraph.containsKey(end))
             findPath(end, start, new ArrayList<String>());
         return result;
     }

     private void findPath(String cur, String goal, ArrayList<String> row){
         if(cur.equals(goal)){
             row.add(0, cur);
             result.add(row);
         }else{
             for(String pre : wordGraph.get(cur)){
                 row.add(0, cur);
                 findPath(pre, goal, new ArrayList<String>(row));
                 row.remove(0);
             }
         }
     }
 }