Word Ladder Java

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.

 Key to solve: BSF + Queue;

  Image the start word is root of Tree, all the transformation is
    derive from start word as down level of root. we need to list all the 
     possible transformation and find match from dict that Traversed by BFS

    Use two Queues: qWord & qDistance
    qWord: record all possible stratified word from dictionary
    qDistance: record length of word ladder
    As a result, we construct a Tree and search by method of BFS

    Time: O(min(26^L, size(dict))) L is length of word
    because in worst case we need either scan all the 26 letters in L times

public class Solution {
    public int ladderLength(String start, String end, Set<String> dict) {
        if(start.length()==0 || end.length()==0 || dict.isEmpty()) return 0;
        Queue<String> qWord=new LinkedList<String>();
        Queue<Integer> qDistance=new LinkedList<Integer>();

        qWord.add(start);
        qDistance.add(1);
        while (!qWord.isEmpty()){
            String word=qWord.poll();
            int len=qDistance.poll();
            if(end.equals(word)){
                return len;
            }
            for(int i=0;i<word.length();i++) {
                char[] charArray=word.toCharArray();
                for (char c = 'a'; c<='z'; c++){
                    charArray[i] =c;

                    String tempStr=new String(charArray);
                    if(dict.contains(tempStr)){
                        qWord.add(tempStr);
                        qDistance.add(len+1);
                        dict.remove(tempStr);
                    }
                }
            }
        }
        return 0;
    }
}