Word Ladder

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence 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"]

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.

思路： Using  BFS . Set a queue to storage the path word and distance. Every time to change one character and check whether in the dictionary.

易错点： 记住 每次添加进 path 的单词从 dictionary 删除掉， 用HashMap 来存储路径 或者创建一个 hashset  来存储已经访问过的节点。

public class Solution {
    public int ladderLength(String start, String end, Set<String> dict) {
        if(dict.size() < 1)
            return 0;
        Queue<String> words = new LinkedList<String>();
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        words.add(start);
        map.put(start, 1);
        while(!words.isEmpty()){
            String word = words.poll();
            int dist = map.get(word);
            if(word.equals(end)){
                return dist;
            }
            for(int i = 0; i < word.length(); i++){
                for(char c = 'a'; c <= 'z'; c++){
                    char[] arr = word.toCharArray();
                    arr[i] = c;
                    String cur = new String(arr);
                    if(dict.contains(cur) && !map.containsKey(cur)){//--
                        map.put(cur, dist + 1);
                        words.add(cur);
                    }
                }
            }
        }
        return 0;
    }
}

public class Solution {
    public int ladderLength(String start, String end, Set<String> dict) {
        if (dict.size() == 0)  
            return 0; 
 
        LinkedList<String> wordQueue = new LinkedList<String>();
        LinkedList<Integer> distanceQueue = new LinkedList<Integer>();
 
        wordQueue.add(start);
        distanceQueue.add(1);
        dict.remove(start);
        
        while(!wordQueue.isEmpty()){
           String curWord = wordQueue.pop();
           int curDist = distanceQueue.pop();
           
           if(curWord.equals(end)){
               return curDist;
           }
           
           for(int i = 0; i < curWord.length(); i++){
               char[] wordArr = curWord.toCharArray();
               for(char c = 'a'; c <= 'z'; c++){
                   wordArr[i] = c;
                   String newWord = new String(wordArr);
                   if(dict.contains(newWord)){
                       wordQueue.add(newWord);
                       distanceQueue.add(curDist + 1);
                       dict.remove(newWord);//To avoid the loop path.
                   }
               }
           }
        }
        return 0;
    }
}