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.

```class Solution {
public:
void dfs(vector<vector<string>> &res,vector<string> str,unordered_map<string,vector<string>> &father,string start, string now)
{
if(now==start)
{
str.push_back(now);
res.push_back(str);
reverse(res.back().begin(),res.back().end());
return;
}
for(const auto &x : father[now])
{
str.push_back(now);
dfs(res,str,father,start,x);
str.pop_back();
}
}
vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
vector<vector<string>> res;
if(start==end)return res;
unordered_set<string> curr,next;
unordered_set<string> all;
unordered_map<string,vector<string>> father;
bool found=false;
curr.insert(start);
while(!curr.empty()&&!found)
{
for(const auto &x : curr)
{
all.insert(x);
}
for(const auto &x : curr)
{
for(int i=0;i<x.length();i++)
{
for(char j='a';j<='z';j++)
{
if(x[i]==char(j))continue;
string tx=x;
tx[i]=char(j);
if(tx==end)found=true;
if(dict.find(tx)!=dict.end()&&all.find(tx)==all.end())
{
next.insert(tx);
father[tx].push_back(x);
}
}
}
}
curr.clear();
swap(curr,next);
}
vector<string> str;
dfs(res,str,father,start,end);
}
};```