花了好几个小时来做这题，我尝试使用了三种方法来答这题，跑这测试用例时都超时了：
① 单向 BFS
② BFS（计算最短转换序列中的单词数目）+ DFS（回溯构建这样长度的所有路径）
③ 双向 BFS
最后没点子了，就拷贝了老师代码仓库中的代码试一下，也是倒在这个测试用例
这测试用例给我搞糊涂了，不知有啥解法可以通过这个测试用例

附上我第三种解法的代码：

class Solution {
public:
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> dict(wordList.cbegin(), wordList.cend());
        if (dict.find(endWord) == dict.cend()) return {};

        unordered_multimap<string, vector<string>> head, tail, *phead, *ptail;
        head.insert({ beginWord, initializer_list<string>{ beginWord } });
        tail.insert({ endWord, initializer_list<string>{ endWord } });
        dict.erase(beginWord);
        dict.erase(endWord);

        vector<vector<string>> ans;
        while (!head.empty() && !tail.empty()) {
            if (head.size() < tail.size()) {
                phead = &head;
                ptail = &tail;
            } else {
                phead = &tail;
                ptail = &head;
            }

            unordered_set<string> del_word_set;
            unordered_multimap<string, vector<string>> temp;
            for (auto &pair: *phead) {
                string word = pair.first;
                for (int i = 0; i < word.size(); i++) {
                    char c = word[i];
                    for (int j = 'a'; j <= 'z'; j++) {
                        word[i] = j;

                        if (ptail->find(word) != ptail->end()) {
                            auto &path1 = pair.second;
                            
                            auto range = ptail->equal_range(word);
                            for (auto iter = range.first; iter != range.second; ++iter) {
                                auto &path2 = iter->second;
                                if (phead == &head) {
                                    ans.push_back(path1);
                                    ans.back().insert(ans.back().end(), path2.crbegin(), path2.crend());
                                } else {
                                    ans.push_back(path2);
                                    ans.back().insert(ans.back().end(), path1.crbegin(), path1.crend());
                                }
                            }
                        } else {
                            if (dict.count(word) == 1) {
                                del_word_set.insert(word);
                                vector<string> new_path = pair.second;
                                new_path.push_back(word);
                                temp.insert({ word, new_path });
                            }
                        }
                    }
                    word[i] = c;
                }
            }

            if (!ans.empty()) {
                break;
            }

            for (auto &del_word: del_word_set) {
                dict.erase(del_word);
            }
            phead->swap(temp);
        }
        return ans;
    }
};