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

Note:

• All words have the same length.
• All words contain only lowercase alphabetic characters.
• 解题思路：

• 这道题可真是耗费我老多时间，提交结果要不就是超时，要不就是内存限制，哎，编程能力急待提高啊。
• 实现代码：（注：该代码未能AC，出现内存限制，忘牛人指正，实在不知错在哪里）
• #include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
using namespace std;

/**
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"]
]
Note:
All words have the same length.
All words contain only lowercase alphabetic characters.
*/

class Solution {
public:
vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
vector<vector<string>> resvec;
if(start.empty() || end.empty() || dict.empty())
return resvec;
unordered_map<string, vector<string>> premap;
//这里需要用到两个vector来模拟两个队列而不是直接用两个队列，是因为需要对队列进行遍历，queue做不到
vector<string> squ[2];
squ[0].push_back(start);
bool qid = false;
bool finish = false;
while(!squ[qid].empty())
{
squ[!qid].clear();
vector<string>::iterator iter;
for(iter = squ[qid].begin(); iter != squ[qid].end(); ++iter)
dict.erase(*iter);//从dict中删除同一层的所有节点，以免造成循环操作
for(iter = squ[qid].begin(); iter != squ[qid].end(); ++iter)//处理同一层节点
{
string curstr = *iter;
for(int i = 0; i < curstr.size(); i++)
{
char t = curstr[i];
for(char j = 'a'; j <= 'z'; j++)
{
if(j == curstr[i])
continue;
curstr[i] = j;
if(curstr == end)
{
finish = true;
premap[curstr].push_back(*iter);

}
else if(dict.count(curstr) > 0)
{
squ[!qid].push_back(curstr);
premap[curstr].push_back(*iter);
}
}
curstr[i] = t;

}
}
if(finish)//说明已经处理到了end节点，可以直接break循环，进行结果重构了
break;
qid = !qid;//表示将要处理的下一层
}
if(premap.count(end) == 0)//表明end节点的父节点不存在，所有没有到end的转换，直接返回空resvec
return resvec;
vector<string> tmp;
getResult(resvec, tmp, premap, start, end);
return resvec;
}

//DFS
void getResult(vector<vector<string> > &resvec, vector<string> &tmp,
unordered_map<string, vector<string> > &premap, string &start, string &cur)
{
tmp.push_back(cur);
if (cur == start)
{
resvec.push_back(tmp);
reverse(resvec.back().begin(), resvec.back().end());
}
else
{
vector<string> v = premap[cur];
for (int i = 0; i < v.size(); i++)
{
getResult(resvec, tmp, premap, start, v[i]);
}
}
tmp.pop_back();
}
};

int main(void)
{
string start("hit");
string end("cog");
string strarr[] = {"hot","dot","dog","lot","log"};
int n = sizeof(strarr) / sizeof(strarr[0]);
unordered_set<string> dict(strarr, strarr+n);
Solution solution;
vector<vector<string>> resvec = solution.findLadders(start, end, dict);
vector<vector<string>>::iterator iter;
for(iter = resvec.begin(); iter != resvec.end(); ++iter)
{
vector<string> tmp = *iter;
vector<string>::iterator it;
for(it = tmp.begin(); it != tmp.end(); ++it)
cout<<*it<<" ";
cout<<endl;
}
return 0;
}

以下附网上大神AC代码一份：

class Solution {
public:
vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict)
{
result_.clear();
unordered_map<string, vector<string>> prevMap;
for(auto iter = dict.begin(); iter != dict.end(); ++iter)
prevMap[*iter] = vector<string>();
vector<unordered_set<string>> candidates(2);
int current = 0;
int previous = 1;
candidates[current].insert(start);
while(true)
{
current = !current;
previous = !previous;
for (auto iter = candidates[previous].begin(); iter != candidates[previous].end(); ++iter)
dict.erase(*iter);
candidates[current].clear();

for(auto iter = candidates[previous].begin(); iter != candidates[previous].end(); ++iter)
{
for(size_t pos = 0; pos < iter->size(); ++pos)
{
string word = *iter;
for(int i = 'a'; i <= 'z'; ++i)
{
if(word[pos] == i)continue;
word[pos] = i;
if(dict.count(word) > 0)
{
prevMap[word].push_back(*iter);
candidates[current].insert(word);
}
}
}
}
if (candidates[current].size() == 0)
return result_;
if (candidates[current].count(end)) break;
}
vector<string> path;
GeneratePath(prevMap, path, end);
return result_;
}

private:
void GeneratePath(unordered_map<string, vector<string>> &prevMap, vector<string>& path, const string& word)
{
if (prevMap[word].size() == 0)
{
path.push_back(word);
vector<string> curPath = path;
reverse(curPath.begin(), curPath.end());
result_.push_back(curPath);
path.pop_back();
return;
}
path.push_back(word);
for (auto iter = prevMap[word].begin(); iter != prevMap[word].end(); ++iter)
GeneratePath(prevMap, path, *iter);
path.pop_back();
}
vector<vector<string>> result_;
};
代码来源：http://blog.csdn.net/doc_sgl/article/details/13341405
-----------------------我和我追猪的梦-----------------------------------------------------------------

作者：mickole
posted @ 2014-04-28 09:41  mickole  阅读(394)  评论(0编辑  收藏  举报