leetcode - 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.

typedef std::pair<std::string,std::string> PAIR;
void  getSolution(std::string &end, std::string& word, std::unordered_multimap<std::string, std::string> &map, std::vector<std::vector<std::string> > &vec, std::vector<std::string> &vec2) {
if(word == end || map.find(word) == map.end()) {
    if(word != end) return;
    vec2.push_back(end);
    vec.push_back(vec2);
    vec2.pop_back();
    return;
}
std::pair<std::unordered_map<std::string, std::string>::iterator, std::unordered_map<std::string, std::string>::iterator> ret;
ret = map.equal_range(word);
while(ret.first != ret.second) {
    vec2.push_back(ret.first->first);
    getSolution(end, ret.first->second, map, vec, vec2);
    vec2.pop_back();
    ret.first++;
}
}
class Solution {
public:
std::vector<std::vector<std::string>> findLadders(std::string start, std::string end, std::unordered_set<std::string> &dict) {
	std::vector<std::vector<std::string>> vec;
    //if(start == end) { vec.push_back(vector<string>(1, start)); return vec; }
    std::unordered_multimap<std::string, std::string> edges;
    std::unordered_set<std::string> previousNodes;
    std::vector<std::unordered_set<std::string> > node_levels(2);
    int curLevel = 0;
    node_levels[curLevel].insert(end);
    std::unordered_set<std::string>::iterator it;
    while(!node_levels[curLevel].empty() && node_levels[curLevel].count(start) == 0) {
        for(it = node_levels[curLevel].begin(); it != node_levels[curLevel].end(); ++it) {
            for(size_t i = 0; i < it->size(); ++i) {
                std::string node(*it);
                for(node[i] = 'a'; node[i] <= 'z'; ++node[i]) {
                    if(node == start) {
                        node_levels[1-curLevel].insert(node);
                        edges.insert(PAIR(start, *it));
                        break;
                    }
                    if(previousNodes.count(node) || node_levels[curLevel].count(node) || dict.count(node) == 0) 
                        continue;
                    node_levels[1-curLevel].insert(node);
                    edges.insert(PAIR(node, *it));
                }
            }
            previousNodes.insert(*it);
        }
        node_levels[curLevel].clear();
        curLevel = !curLevel;
    }
    previousNodes.clear();
    if(node_levels[curLevel].empty()) return vec;
    std::vector<std::string> vec2;
    getSolution(end, start, edges, vec, vec2);
    return vec;
}
};