[Leetcode 126] Word Ladder II

Question

Given two words (beginWord and endWord), and a dictionary’s word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:

Only one letter can be changed at a time

Each transformed word must exist in the word list. Note that beginWord is not a transformed word.

For example,

Given:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log","cog"]
Return
[
["hit","hot","dot","dog","cog"],
["hit","hot","lot","log","cog"]
]

思路

这个题是一个无向图查找所有的最短路径的题。

我首先是想到了用深度搜索（DFS）去做。但是写出的代码只能通过 wordList 比较小的情况，wordList大的时候总是报 Time Limit Exceed错误。我在vs上调试时 发现原因是 递归调用层次太深，程序就死了。

后面我采用空间换时间策略， 用BFS算法重写， 通过了。

另外有一种思路是 BFS+DFS. 即先用BFS 把无向图变成有向图， 把每个节点的父节点和子节点保存下来，再用DFS 去查找最短路径，有兴趣的可以在网上找一下

-代码如下：

class Solution {
public:
/* compare() 是比较string a 和 b 有几个字母不同 */
bool compare(string &a, string &b) {
int cnt = 0;
if (a.size() == b.size())
for (int i = 0; i < a.size(); ++i) {
if (a[i] != b[i]) {
++cnt;
if (cnt > 1) break;
}
}
return cnt == 1;
}
/*
build() 找出节点 word 的所有相邻节点，（即找出与 word 只有一个字符不同的所有 string）, 保存到   set<string> 中
*/
set<string> build(string word, vector<string> &wordList) {
set<string> ret;
for (auto a : wordList) {
if (compare(a, word)) {
ret.insert(a);
}
}
return ret;
}

vector<vector<string>> findLadders(string beginWord, string endWord, vector<string> wordList) {
vector<vector<string>> ret;  // 返回
if ((find(wordList.begin(), wordList.end(), endWord)) == wordList.end()) return ret;
map<string, set<string>> str_set;
queue<string> s;
//记录从初始节点beginWord到当前节点的最短路径的长度
map<string, int> flash;
//记录从初始节点beginWord到当前节点的所有最短路径的，这些路径保存到set<vector<string>>中
map<string, set<vector<string>>> route;
//建立无向图，保存到 str_set 中
for (auto a : wordList) {
str_set[a] = build(a, wordList);
flash[a] = 0;
}
//将beginWord加入到图中，如果beginWord本身在图中也不会有影响
str_set[beginWord] = build(beginWord, wordList);
flash[beginWord] = 1;  //beginWord 到beginWord 路径长度为1，相应路径保存到route[beginWord]中
route[beginWord].insert({ beginWord });
s.push(beginWord);
while (!s.empty()) {
string val = s.front();
for (auto &a : str_set[val]) {
//遍历val的所有邻接点， flash[a] == 0 表示该节点该节点 第一次被访问，
//flash[a] >= (flash[val] + 1) 表示发现比当前找到的路径的长度相等或者更短的新路径，要更新
if (flash[a] == 0 || flash[a] >= (flash[val] + 1)) {

//找到更短的路径，则把先前保存的路径清除
if (flash[a] > flash[val] + 1){
route[a].clear();
flash[a] = flash[val] + 1;
}
int temp = 1;
for (auto b : route[val]) {
b.push_back(a);
//如果该路径已经保存在已有路径中，是重复访问，跳出，temp置0
if (route[a].find(b) != route[a].end())
{
temp = 0;
break;
}
route[a].insert(b);
}
//更新后的节点要重新加入到 队列中
if (temp)
s.push(a);
}
if (a == endWord) break;
}
s.pop();
}
for (auto a : route[endWord])
ret.push_back(a);
return ret;
}
};