LeetCode 127. Word Ladder

1. 题目描述

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

Only one letter can be changed at a time

Each intermediate word must exist in the word list

For example,

Given:

beginWord = “hit”

endWord = “cog”

wordList = [“hot”,”dot”,”dog”,”lot”,”log”]

As one shortest transformation is “hit” -> “hot” -> “dot” -> “dog” -> “cog”,

return its length 5.

Note:

Return 0 if there is no such transformation sequence.

All words have the same length.

All words contain only lowercase alphabetic characters.

2. 解题思路

这道题目可以使用图的观点来看待他， 也就是找一个节点到另一个节点之间的最短路径长度问题， 但是图中， 求解这个问题一般是采用Dijkstra 方法求解的， 而且一般处理的还是无向带权图， 这里就不适用了。所以基本上就剩下两种思路DFS 和 BFS。

我们一开始没有过多的考虑到底是使用 DFS 还是 BFS 的问题， 因为在一般情况下， DFS 和 BFS 都是可以处理这类问题的， 并且由于 DFS 写的比较顺手， 于是华丽丽的掉到坑里面去了。

对于这道题目， 非常适合使用BFS 的搜索框架， 搜索的层数就是 两者之间的距离

而像我们一开始试图采用的 DFS， 需要遍历整个搜索空间， 这个时间的消耗的巨大的。

3. code

这里需要说明的是， 我们这里采用的 BFS， 由于需要统计他的层数， 我们想到的是借助 层次遍历的思想， 利用两个队列的切换， 来实现层数的增加。

在 GetNeighbours 这个函数中， 注释的那部分代码是一定需要添加的， 可以节省很大的搜索量， 如果没有这部分代码， 多个路径会访问相同的节点， 造成重复访问， 最直接的表现就是 TLE了。

class Solution {
public:
int ladderLength(string beginWord, string endWord, unordered_set<string>& wordList) {
return Search(beginWord, endWord, wordList);
}

private:
int Search(string startWord, string endWord, unordered_set<string> & wordList){
if (startWord == endWord)
return 0;

wordList.insert(endWord);

vector<queue<string>> myqueue(2, queue<string>());
int count = 0;
myqueue[0].push(startWord);
int index = 0;
while (!myqueue[0].empty() || !myqueue[1].empty()){
count++;
while (!myqueue[index].empty()){
string front = myqueue[index].front();
myqueue[index].pop();

if (front == endWord)
return count;

unordered_set<string> toVisited;
GetNeighbours(front, wordList, toVisited);

for (string item : toVisited){
myqueue[1 - index].push(item);
}
}
index = 1 - index;
}

return 0;
}

// 获取相邻节点
void GetNeighbours(string item, unordered_set<string> & wordList, unordered_set<string> & toVisited){
wordList.erase(item);
for (int i = 0; i != item.size(); i++){
string tmp = item;
for (int j = 0; j != 26; j++){
tmp[i] = 'a' + j;

if (wordList.find(tmp) != wordList.end()){
toVisited.insert(tmp);
wordList.erase(tmp);     // new improvement 这句话一定要加， 可以节省很大的搜索量
}
}
}
}
};

4. 大神的代码

4.1 Demo1 BFS

他是使用toVisit 的 size 来标记这一层是否遍历完成的， ie, 在说明标记 TAG1 处，执行完这个for 循环之后， 上一层的节点是被全部访问过了的， 容器中剩余的都是这一层的带访问的节点。

class Solution {
public:
int ladderLength(string beginWord, string endWord, unordered_set<string>& wordDict) {
wordDict.insert(endWord);
queue<string> toVisit;
addNextWords(beginWord, wordDict, toVisit);
int dist = 2;
while (!toVisit.empty()) {
int num = toVisit.size();
// 我是说明标记 TAG1
for (int i = 0; i < num; i++) {
string word = toVisit.front();
toVisit.pop();
if (word == endWord) return dist;
addNextWords(word, wordDict, toVisit);
}
dist++;
}
}
private:
void addNextWords(string word, unordered_set<string>& wordDict, queue<string>& toVisit) {
wordDict.erase(word);
for (int p = 0; p < (int)word.length(); p++) {
char letter = word[p];
for (int k = 0; k < 26; k++) {
word[p] = 'a' + k;
if (wordDict.find(word) != wordDict.end()) {
toVisit.push(word);
wordDict.erase(word);
}
}
word[p] = letter;
}
}
};

4.2 Bi-BFS 算法

由于 BFS 算法搜索到后期， 搜索的量是非常大的， 于是可以考虑使用 双向 BFS 搜索的方法， 每次从小端开始搜索， 这样相比 单纯的BFS 可以节省更多的搜索量

class Solution {
public:
int ladderLength(string beginWord, string endWord, unordered_set<string>& wordDict) {

int srcLen = beginWord.size(), destLen = endWord.size(), dictSize = wordDict.size();
if((srcLen != destLen) || !srcLen || !dictSize) return 0; // abnormal cases, return 0; // abnormal cases, just return 0

unordered_set<string> unusedWords = wordDict; // words that never visited before
unordered_set<string> activeWords[3];
int startSet = 0, endSet = 1, nextSet = 2, curDepth = 2, i;
char tempC, j;

activeWords[startSet].insert(beginWord);
activeWords[endSet].insert(endWord);
unusedWords.erase(beginWord);
unusedWords.erase(endWord);

while(!activeWords[startSet].empty())
{ // do BFS on startSet
for(auto it : activeWords[startSet])
{
for(i = 0 ; i<srcLen; ++i)
{
for( tempC = it[i], j='a'; j<='z'; ++j)
{
if(tempC == j) continue;
it[i] = j;
if(activeWords[endSet].count(it)>0)
return curDepth ;// if the new word is in the endSet, then we find a path
if(unusedWords.count(it))
{ // otherwise, if it is a new word that has never been visited
activeWords[nextSet].insert(it);
unusedWords.erase(it);
}
}// FOR j
it[i] = tempC;
} // FOR i
} //FOR it
++curDepth;
swap(startSet, nextSet); // swap the startSet and the nextSet
if(activeWords[startSet].size() > activeWords[endSet].size()) swap(startSet, endSet); // if needed, switch the search direction
activeWords[nextSet].clear();
}
return 0;
}
};