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.

Analysis: As for a shortest path problem like this one, BFS is always the best solution. Note that we need to maintain a visited list to store the words that have been visited previously. 

public class Solution {
    public int ladderLength(String start, String end, HashSet<String> dict) {
        HashMap<String, Boolean> visited = new HashMap<String, Boolean>();
        Queue<String> frontier = new LinkedList<String>();
        visited.put(start, true);
        frontier.add(start);
        
        int transformation = 1;
        while(!frontier.isEmpty()) {
            Queue<String> next = new LinkedList<String>();
            while(!frontier.isEmpty()) {
                if(frontier.peek().equals(end)) return transformation;
                char[] current = frontier.poll().toCharArray();
                for(int i=0; i<current.length; i++) {
                    char holder = current[i];
                    for(char j='a'; j<='z'; j++) {
                        if(j != current[i]) {
                            current[i] = j;
                            String tem = new String(current);
                            if(dict.contains(tem) && !visited.containsKey(tem)) {
                                next.add(tem);
                                visited.put(tem, true);
                            }
                        }
                    }
                    current[i] = holder;
                }
            }
            frontier = next;
            transformation++;
        }
        
        return 0;
    }
}