127. Word Ladder

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:

1. Only one letter can be changed at a time.
2. Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

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.

Example 1:

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Example 2:

Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

---

关键字 "...find the length of shortest transformation sequence from beginWord to endWord..." 最短路径，用BFS解决：1.需要Queue来做BFS，2.hash table来避免重复。
BFS：起点是beginWord，边是变换成和当前word只差一个字母并且存在在字典里的词。
这道题要求出最短路径是多少（多少层），当用BFS遍历时，需要明确知道什么时候当前层结束，开始下一层，层数此时+1。最简单的做法是用两个queue来实现：queue1装当前层的节点，queue2装下一层节点，当queue1为空时，代表当前层节点遍历结束.

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> dict(wordList.begin(),wordList.end()); //hashtable containing unvisited words
        int length = 1;
        queue<string> queue1; //current level
        queue<string> queue2; //next level
        queue1.push(beginWord);
        
        //BFS
        while(!queue1.empty()){
            string currWord = queue1.front();
            if(currWord==endWord){ //equals endWord: find the transformation
                return length;
            }
            queue1.pop();
            
            //checking neighbors
            //1. each letter can be changed
            for(int i=0;i<currWord.size();i++){
                char old = currWord[i];
                    
                //2.each letter can be changed to 26 letters
                for(int c='a';c<='z';c++){
                    //need to be a diffent word from the current word
                    if(c!=old){
                        currWord[i]=c;
                        //3. if the word is a valid transformation: this new word is in dictionary(not visited before)
                        if(dict.find(currWord)!=dict.end()){
                            queue2.push(currWord);
                            dict.erase(currWord);
                        }
                    }
                }
                
                //restore currWord:
                currWord[i]=old;
            }
            
            if(queue1.empty()){ 
                length++;
                queue1=queue2;
                queue<string> temp;
                queue2 = temp;
            }
        }
        
        return 0;
    }
};