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:

Only one letter can be changed at a time

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"]
]

class Solution {
public:
unordered_map<string,int> wordMap;
vector<string> wordVec;

void constructAdj(vector<vector<int> > &adj){
unordered_map<string,int>::iterator iter=wordMap.begin(),tmp;
while(iter!=wordMap.end()){
string s=iter->first;
for(int i=0;i<s.size();i++){
char t=s[i];
for(char c='a';c<='z';c++){
if(c!=t){
s[i]=c;
tmp=wordMap.find(s);
if(tmp!=wordMap.end()){
adj[iter->second].push_back(tmp->second);
}
}
}
s[i]=t;
}
iter++;
}
}

void getPath(vector<vector<string> > &result, vector<set<int> > &prev,
vector<int> &path,const int &s,int curr){
if(curr==s){
vector<string> vec;
for(int i=path.size()-1;i>=0;i--){
vec.push_back(wordVec[path[i]]);
}
result.push_back(vec);
return;
}
set<int>::iterator iter=prev[curr].begin();
while(iter!=prev[curr].end()){
path.push_back(*iter);
getPath(result,prev,path,s,*iter);
path.pop_back();
iter++;
}
}

vector<vector<string> > findLadders(string start, string end,
unordered_set<string> &dict) {
vector<vector<string> > result;
dict.insert(start);
dict.insert(end);

wordMap.clear();
wordVec.clear();
unordered_map<string,int>::iterator ii;
unordered_set<string>::iterator iter=dict.begin();

int index=0,s=0,e=0,t=0,tmp=0;
while(iter!=dict.end()){
wordMap.insert(make_pair(*iter,index));
wordVec.push_back(*iter);
index++;
iter++;
}
ii=wordMap.find(start);
s=ii->second;
ii=wordMap.find(end);
e=ii->second;

vector<vector<int> > adj(index,vector<int>());
vector<set<int> > prev(index,set<int>());
constructAdj(adj);

vector<int> level(index,0);
queue<int> wordQueue;
wordQueue.push(s);
level[s]=1;

while(!wordQueue.empty()){
tmp=wordQueue.front();
if(tmp==e){
break;
}
wordQueue.pop();

for(int i=0;i<adj[tmp].size();i++){
t=adj[tmp][i];
if(level[t]==0){
level[t]=level[tmp]+1;
wordQueue.push(t);
prev[t].insert(tmp);
}else if(level[t]==level[tmp]+1){
prev[t].insert(tmp);
}
}
}

vector<int> path;
path.push_back(e);
getPath(result,prev,path,s,e);
return result;
}
};