【leetcode】Word Ladder 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"]
  ]

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.

 

 

 

先使用BFS，得到father，记录广度搜索路径上，每一个节点的父节点（可以有多个）

因此采用 unordered_map<string,unordered_set<string>> 数据结构

 

例如father["aaa"]=["baa","caa"]表示了aaa在广度优先搜素路径上的父节点为"baa","caa";

 

广度优先搜索时，从start开始，

找到与start相邻的节点 node1,node2,.....;

并记录每一个节点的父节点为start

 

然后从node1，node2...开始，遍历下一层

 

直到找到end节点停止（注意，必须上一层节点全部遍历完

 

 

找到father 路径后，从end开始往前dfs就可以得到所有的结果了

 

class Solution {
public:
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
       
        vector<vector<string>> result;
        unordered_set<string> unvisited=dict;
       
        dict.insert(start);
        dict.insert(end);
       
        unordered_map<string,unordered_set<string>> father;
        if(unvisited.count(start)==0) unvisited.erase(start);
       
       
        unordered_set<string> curString,nextString;
        curString.insert(start);
       
       
        while(curString.count(end)==0&&curString.size()>0)
        {
           
            for(auto it=curString.begin();it!=curString.end();it++)
            {
                string word=*it;
                for(int i=0;i<word.length();i++)
                {
                    string tmp=word;
                    for(int j='a';j<='z';j++)
                    {
                        if(tmp[i]==j) continue;
                        tmp[i]=j;
                        if(unvisited.count(tmp)>0)
                        {
                            nextString.insert(tmp);
                            father[tmp].insert(word);
 
                        }
                       
                    }
                }
            }
           
            if(nextString.size()==0) break;
           
            for(auto it=nextString.begin();it!=nextString.end();it++)
            {
                //必须遍历完了curString中所有的元素，才能在unvisited中删除（因为可能有多个父节点对应着该节点）
                unvisited.erase(*it);
            }
           
            curString=nextString;
            nextString.clear();
           
        }
       
        if(curString.count(end)>0)
        {
            vector<string> tmp;
            dfs(father,end,start,result,tmp);
        }
       
        return result;
    }
   
   
    void dfs(unordered_map<string,unordered_set<string>> &father,string end,string start,vector<vector<string>> &result,vector<string> tmp)
    {
        tmp.push_back(end);
        if(end==start)
        {
            reverse(tmp.begin(),tmp.end());
            result.push_back(tmp);
            return;
        }
       
        for(auto it=father[end].begin();it!=father[end].end();it++)
        {
            dfs(father,*it,start,result,tmp);
        }
    }
};