Word Ladder Problem (DFS + BFS)

Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence 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.

For example,

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

As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Note:

• Return 0 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.

UPDATE (2017/1/20):
The wordList parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

Code:

 class Solution {
 public:
     vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {
         //1.convert vector to unordered_set
         unordered_set<string> wordDict;
         for(int i=; i<wordList.size(); i++)
         {
             wordDict.insert(wordList[i]);
         }
         if(wordDict.find(endWord) == wordDict.end()) return vector<vector<string>>();

         //2.record each node's pre_node from begin to end using bfs strategy
         unordered_map<string, vector<string>> preNode;
         bfs(preNode, wordDict, beginWord, endWord);

         //3.search all the road using dfs from end to start
         vector<vector<string>> res;
         vector<string> temp;
         dfs(beginWord, endWord, temp, preNode, res);

         return res;
     }

 private:
     void bfs(unordered_map<string, vector<string>>&preNode,
              unordered_set<string>& wordDict, string beginWord, string endWord)
     {
         queue<string> q;
         unordered_set<string> visit;
         visit.insert(beginWord);
         vector<string> connect;
         q.push(beginWord);
         while(!q.empty())
         {
             int len = q.size();
             vector<string> tmpVisit;
             while(len--)
             {
                 string current = q.front();
                 q.pop();
                 isConnect(connect, wordDict, current, endWord, visit);
                 for(int i=; i<connect.size(); i++)
                 {
                     if(visit.find(connect[i]) == visit.end()) // not visited
                     {
                         if(preNode[connect[i]].empty())
                         {
                             tmpVisit.push_back(connect[i]);
                             q.push(connect[i]);
                         }
                         preNode[connect[i]].push_back(current);
                     }
                 }
             } //each level
             for(int j=; j<tmpVisit.size(); j++)
             {
                 visit.insert(tmpVisit[j]);
             }
             if(visit.find(endWord) != visit.end())
                 return;
         }
     }

     void isConnect(vector<string>& connect, unordered_set<string>& wordDict,
                   const string& current, const string& end, unordered_set<string>& visit)
     {
         connect.clear();
         string cur = current;
         for(int i=; i<cur.size(); i++)
         {
             char t = cur[i];
             for(char c='a'; c<'z'; c++)
             {
                 if(c == t) continue;
                 cur[i] = c;
                 if((wordDict.find(cur) != wordDict.end()) && visit.find(cur) == visit.end())
                 {
                     connect.push_back(cur);
                 }
             }
             cur[i] = t;
         }
     }

     void dfs(const string& beginWord, const string& t, vector<string> tmp,
             unordered_map<string, vector<string>>& preNode, vector<vector<string>>& res)
     {
         if(t == beginWord)
         {
             tmp.push_back(beginWord);
             vector<string> tmpres(tmp.rbegin(), tmp.rend());
             res.push_back(tmpres);
             return;
         }
         tmp.push_back(t);
         for(int i=; i<preNode[t].size(); i++)
         {
             dfs(beginWord, preNode[t][i], tmp, preNode, res);
         }
     }
 };