leetcode 127. Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord toendWord, such that:Only one letter can be changed at a time.
Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
For example,Given:
beginWord = 

"hit"

endWord = 

"cog"

wordList = 

["hot","dot","dog","lot","log","cog"]

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.
You may assume no duplicates in the word list.
You may assume beginWord and endWord are non-empty and are not the same.
UPDATE (2017/1/20):
The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.
给出一个beginWord,一个endWord,每次通过wordList做一次转换，把beginWord转换成endWord，求整个转换链的长度。
每次转换只能换一个字符。
由于转换的路径不止一条，通过深度优先搜索得到的路径可能不是最佳方案，不大容易得到正确答案。
使用广度优先遍历，每次从当前节点出发，搜索出所有可以转换的字符串（即进行一层广度搜索），此时转换链的长度+1；
一次搜索下去，当搜到endWord时，搜索的层数+1   即为转换链的长度。
看到有个博客对此方法的解释比较清晰：（https://www.jianshu.com/p/753bd585d57e）













搜索到新一层时，得到的方案可能有多个，比如hot-lot,hot-dot，这时应该都视作下一层的搜索起点，才能保证每一层的搜索是完整的

AC代码： public int ladderLength(String beginWord, String endWord, List<String> wordList) {
if(!wordList.contains(endWord)){
return 0;
}
if(beginWord.equals(endWord)){
return 0;
}
if(compareTwoStr(beginWord,endWord)){
return 2;
}

List<String> visited = new ArrayList<String>();
List<String> remain = new ArrayList<String>(wordList);
visited.add(beginWord);
int index = 0;
int visitLen = 1;
int count = 1;
while(!visited.contains(endWord)){
boolean found = false;
for(int i=index;i<index+visitLen;i++){
for(int j=remain.size()-1 ;j>=0; j--){
if(compareTwoStr(remain.get(j), visited.get(i))
&& !visited.contains(remain.get(j))){
visited.add(remain.get(j));
found = true;
remain.remove(j);
}
}

}
if(!found){
return 0;
}
count++;
index += visitLen;
visitLen = visited.size() - index;
}

return count;

}

//辅助函数，判断两串只相差1字符
public static boolean compareTwoStr(String str1,String str2){
int count = 0;
for(int i=0;i<str1.length();i++){
if(str1.charAt(i) != str2.charAt(i)){
count++;
if(count>1)
return false;
}
}
return count == 1;
}