Word Ladder II

-----QUESTION-----

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.

-----SOLUTION-----

class Solution {
public:
    vector<vector<string>> findLadders(string start, string end,unordered_set< string > &dict){
        result.clear();
        unordered_map<string, vector<string>> adj;
        unordered_set<string> set_to_push; //可能存在两个word的pre相同，如果用queue会有重复，所以使用set
        queue<string> que_to_pop;
        que_to_pop.push(end);
        string current, tmp;
        bool stopFlag = false;
        vector word_to_delete;
        word_to_delete.push_back(start);
        word_to_delete.push_back(end);
        
        //find the shortest path from start to end
        while(!que_to_pop.empty()){
            current = que_to_pop.front();
            que_to_pop.pop();
            for(int i = 0; i < current.size(); i++){
                tmp = current;
                for(char c = 'a'; c <= 'z'; c++){
                    if(current[i]==c) continue;
                    tmp[i] = c;
                    if(tmp == start){
                        stopFlag = true;
                        adj[tmp].push_back(current);
                    }
                    else if(!stopFlag && dict.find(tmp)!=dict.end()) {
                        set_to_push.insert(tmp);
                        adj[tmp].push_back(current);
                        word_to_delete.push_back(tmp);
                    }
                }
            }
            if(que_to_pop.empty()) { // end a level
                if(stopFlag) break;
                for(unordered_set< string >::iterator it = set_to_push.begin(); it!=set_to_push.end(); it++){
                    que_to_pop.push(*it);
                }
                set_to_push.clear();
                for(int i = 0; i < word_to_delete.size(); i++) dict.erase(word_to_delete[i]);
                word_to_delete.clear();
            }
        }
        
        //push in the result
        vector< string > item;
        pushResult(start, end, adj, item);
        return result;
    }
    
    void pushResult(string pre, string end, unordered_map<string, vector<string>>& adj, vector<string>& item){
        if(pre == end){
            item.push_back(end);
            result.push_back(item);
            item.pop_back();
            return;
        }
        for(int i = 0 ; i < adj[pre].size(); i++){
            item.push_back(pre);
            pushResult(adj[pre][i], end, adj,item);
            item.pop_back();
        }
    }
    
private:
    vector<vector<string>> result;
};

BFS：Memory limitexceeded

class Solution {
public:
    vector<vector<string>> findLadders(string start, string end, unordered_set<string>&dict) {
        int wordLen = start.length();
        string current;
        queue<string> queue_to_push; //prepared for next loop
        queue<string> queue_to_pop; //string to deal in this loop
        vectorvStr;
        vector< vector< string >> result;
        bool endFlag = false;
      
        vStr.push_back(start);
        queue_to_pop.push(vStr);
        while(!queue_to_pop.empty())
        {
            vStr = queue_to_pop.front();
            queue_to_pop.pop();
            current = *(vStr.end()-1);
         
            for (int i = 0; i < wordLen; i++){
                int j = 'a';
                for (; j <= 'z'; j++)  
                {  
                    if (j == current[i]) //skip the current character  
                        continue;  
                    char temp = current[i];  
                    current[i] = j;  
                    if(current==end)
                    {
                        vStr.push_back(current);
                        result.push_back(vStr);
                        endFlag = true;
                        break;
                    }
                    if (!endFlag && dict.count(current) > 0) //exist such a word in the dict  
                    {  
                        vStr.push_back(current);
                        queue_to_push.push(vStr);
                        vStr.pop_back();
                    }  
                    current[i] = temp;  //restore the string
                }
                if(j <= 'z') break;
            }
                
            if(queue_to_pop.empty())
            {
                if(endFlag) break;
                swap(queue_to_push, queue_to_pop);
            }
        }
        return result;
    }
};