算法描述：

Given two words (beginWord and endWord), and a dictionary‘s word list, find all shortest transformation sequence(s) 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 an empty list 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:
[
  ["hit","hot","dot","dog","cog"],
  ["hit","hot","lot","log","cog"]
]

Example 2:

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

Output: []

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.
解題思路：這道題比較難。深搜加廣搜，廣搜用於判斷是否有通路，並構建連通圖。深搜用於獲取所有結果。

    vector<vector<string>> findLadders(string
 
 beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> dict(wordList.begin(),wordList.end());
        dict.erase(beginWord);
        vector<vector<string>> results;
        queue<string> que;
        que.push(beginWord);
        
        unordered_map<string,int> levels;
        unordered_map<string,vector<string>> graph; 
        int level = 0;
        bool isFound = true;
        while(!que.empty()){
            level++;
            int levelSize = que.size();
            
            for(int i=0; i< levelSize; i++){
                string curWord = que.front();
                que.pop();
                string copyWord = curWord;
                for(int i=0; i < curWord.size(); i++){
                    char t = copyWord[i];
                    for(char c = ‘a‘; c <= ‘z‘; c++){
                        copyWord[i]=c;
                        if(copyWord == curWord) continue;
                        
                        if(dict.find(copyWord)!=dict.end()){
                            levels[copyWord]=level+1;
                            graph[curWord].push_back(copyWord);
                            dict.erase(copyWord);
                            
                            if(copyWord==curWord){
                                isFound = true;
                            }else{
                                que.push(copyWord);
                                
                            }
                        }else{
                            auto it = levels.find(copyWord);
                            if(it!=levels.end() && it->second == level+1){
                                graph[curWord].push_back(copyWord);
                                
                            }
                        }
                     copyWord[i]=t;   
                    }
                }   
            }  
        }
        if(isFound){
            vector<string> temp({beginWord});
            backtracking(results,temp,graph,beginWord,endWord);
        }
        return results;
    }
    
    void backtracking(vector<vector<string>>& results,vector<string>& temp,unordered_map<string, vector<string>> &graph,string beginWord,string endWord){
        if(beginWord == endWord){
            results.push_back(temp);
            return;
        }
        
        if(graph.find(beginWord)!=graph.end()){
            for(auto curWord:graph[beginWord]){
                temp.push_back(curWord);
                backtracking(results, temp, graph, curWord, endWord);
                temp.pop_back();
            }
        }
    }

LeetCode-126-Word Ladder II