126. Word Ladder II

问题：

给定StartWord和EndWord，在给定的dict中寻找每次值变换一个字母，最终从StartWord能够推移到EndWord的所有最短序列。

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.

　　

解法1:

单向BFS找到路径关系：

1.引入队列q，保存每一步的所有展开结果。在每一步的结尾，用q去替换掉目标队列queue

即从queue一次读取，处理，将结果保存至q，再用q去替换掉queue。

2.每一次的处理：

首先从已经处理过得到的新queue中的元素，从dict中删除。（由于得到queue的方法，即是dict中存在，则保存至queue）

然后遍历queue的每一个word，进行以下处理：

对word的每一个字符，进行a～z字母替换，

判断：1，如果==endWord，则标记found找到。同时记录该路径到children图中。

         2，如果dict中存在，则加入新queue中（这里是先保存到q，之后在整体和queue替换），同时记录该路径关系到children图中。

 

构建children图，key：A字符串，value：B字符串，（由A变化一个字符得到多种可能的B）

unordered_map<string,vector<string>> children;
children[parent].push_back(child);

 

再通过children图进行DFS，构建所有path结果数组。

        vector<string> path={beginWord};
        if(found){
            getPath(children, beginWord, endWord, path, res);
        }

DFS 递归函数：

    void getPath(unordered_map<string,vector<string>>& children, string beginWord, string endWord, vector<string>& path, vector<vector<string>>& res) {
        if(beginWord==endWord){
            res.push_back(path);
            return;
        }
        const auto find = children.find(beginWord);
        if(find==children.end()) return;
        for(const string child: find->second){
            path.push_back(child);
            getPath(children, child, endWord, path, res);
            path.pop_back();
        }
    }

 

解法2:

diff解法1: 

双向 查找路径关系。每次选取size最短的作为对象，进行展开查找。

将解法1中的对象队列queue，改为q1和q2，

若q1短，那么本次将q1看作queue，q2看作endWord，反之亦然。

所做处理皆同方法1，

只有children的构建，由于双向构建，正向处理的情况下，children构建方法同解法1，

反向处理（由endWord向start推）的情况下，parent和child对掉。

要判定是否为正向，则需要引入变量 backward。

代码参考：

解法1:

class Solution {
public:
    void getPath(unordered_map<string,vector<string>>& children, const string beginWord, const string endWord, vector<string>& path, vector<vector<string>>& res) {
        if(beginWord==endWord){
            res.push_back(path);
            return;
        }
        auto find=children.find(beginWord);
        if(find==children.end()) return;
        for(const string& child:find->second){
            path.push_back(child);
            getPath(children, child, endWord, path, res);
            path.pop_back();
        }
    }
    
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        vector<vector<string>> res;
        unordered_set<string> dict(wordList.begin(), wordList.end());
        unordered_set<string> queue={beginWord}, p;
        unordered_map<string,vector<string>> children;
        bool found=false;
        if(dict.count(endWord)==0)return res;
        while(!queue.empty()&&!found){
            for(const string& word: queue){
                dict.erase(word);
            }
            for(const string& word: queue){
                string cur=word;
                for(int j=0; j<=word.length(); j++){
                    char ch=cur[j];
                    for(char i='a'; i<='z'; i++){
                        cur[j]=i;
                        if(cur==endWord){
                            found=true;
                            children[word].push_back(cur);
                        }else if(dict.count(cur)&&!found){
                            p.insert(cur);//下一次待检索
                            children[word].push_back(cur);
                        }
                    }
                    cur[j]=ch;
                }
            }
            swap(queue,p);
            p.clear();
        }
        vector<string> path={beginWord};
        if(found){
            getPath(children, beginWord, endWord, path, res);
        }
        return res;
    }
};

解法2:

class Solution {
public:
    void getPath(unordered_map<string,vector<string>>& children, string beginWord, string endWord, vector<string>& path, vector<vector<string>>& res) {
        if(beginWord==endWord){
            res.push_back(path);
            return;
        }
        const auto find = children.find(beginWord);
        if(find==children.end()) return;
        for(const string child: find->second){
            path.push_back(child);
            getPath(children, child, endWord, path, res);
            path.pop_back();
        }
    }
    vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
        vector<vector<string>> res;
        unordered_set<string> dict(wordList.begin(), wordList.end());
        unordered_set<string> q1={beginWord}, q2={endWord};
        bool backward=false;
        unordered_map<string,vector<string>> children;
        bool found=false;
        if(dict.count(endWord)==0)return res;
        while(!q1.empty()&&!q2.empty()&&!found){
            if(q1.size()>q2.size()){
                backward=!backward;
                swap(q1,q2);
            }
            for(const string& word: q1){
                dict.erase(word);
            }
            for(const string& word: q2){
                dict.erase(word);
            }
            unordered_set<string> q;
            for(const string& word: q1){
                string cur=word;
                for(int j=0; j<=word.length(); j++){
                    char ch=cur[j];
                    for(char i='a'; i<='z'; i++){
                        cur[j]=i;
                        if(q2.count(cur)){
                            found=true;
                            if(!backward){
                                children[word].push_back(cur);
                            }else{
                                children[cur].push_back(word);
                            }
                        }else if(dict.count(cur)&&!found){
                            q.insert(cur);//下一次待检索
                            if(!backward){
                                children[word].push_back(cur);
                            }else{
                                children[cur].push_back(word);
                            }
                        }
                    }
                    cur[j]=ch;
                }
            }
            swap(q1,q);
            q.clear();
        }
        vector<string> path={beginWord};
        if(found){
            getPath(children, beginWord, endWord, path, res);
        }
        return res;
    }
};