[LeetCode]—Word LadderII 单词递推II

Word Ladder II

 

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

1. Only one letter can be changed at a time
2. Each intermediate word must exist in the dictionary

For example,

Given:
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

Return

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

       在wordLadder 基础上，需要记录路径，记录前驱节点，最后使用深搜来查找路径。要保证路径最短，那么要注意同层之间不能互指，访问过的结点不能再访问。

    

学习自：https://gitcafe.com/soulmachine/LeetCode

class Solution {
public:
    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
           unordered_set<string> visited; //判重
           unordered_set<string> current,next; //当前层和下一层，用集合是为了去重
           unordered_map<string,vector<string> > father;

           int level=0;  //层数
           bool found=false;

           current.insert(start);
           while(!current.empty() && !found){
                ++level;
                //将本层全部置为已访问，防止同层之间互指，导致路径非最短
                for(auto word : current)
                    visited.insert(word);
                for(auto word : current){
                    for(size_t i=0;i<word.size();++i){
                        string new_word=word;
                        for(char c='a';c<='z';c++){
                            if(c==new_word[i])continue;
                            swap(c,new_word[i]);

                            if(new_word==end)found=true; //找到了

                            if(visited.count(new_word)==0
                                    && (dict.count(new_word)>0 || new_word==end)){
                                next.insert(new_word);
                                father[new_word].push_back(word);
                            }
                            swap(c,new_word[i]);
                        }

                    }
                }
                current.clear();
                swap(current,next);
           }
            vector<vector<string> > result;
            if(found){
                vector<string> path;
                buildPath(father,path,start,end,result);
            }
            return result;
    }
private:
    void buildPath(unordered_map<string,vector<string> > &father,
            vector<string> &path,const string &start,const string &word,
            vector<vector<string> > &result){
        path.push_back(word);
        if(start==word){
         result.push_back(path);
         reverse(result.back().begin(),result.back().end());
        }else{
            for (auto f : father[word])
                buildPath(father,path,start,f,result);
        }
        path.pop_back();
    }
};