Leetcode | Word Ladder

Given two words (start and end), and a dictionary, find the length of shortest transformation sequence 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"]
As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

拿到题目后的第一想法就是BFS，然后要注意怎么找到它的邻居。假设dict里有m个word，每个word的长度为n，找邻居有三种方式：

1. 遍历dict里所有的word，判断与当前word相交是不是只是一个字符，那么每次找邻居的时间复杂度为O(nm)。

2. 预先计算好所有的word之间是不是可以相互转换，O(nm^2)，显然不适合；

3. 遍历当前word的每个位置，把当前位置变成另一个字符，判断新产生的word是不是在dict里，时间复杂度为(26*n)；

综上，选择第3种方式。

第二个注意点就是BFS的退出条件，如果放在queue的pop之后再判断是否等于end，那么就会额外地多一些开销，最好就是在找邻居的时候，如果遇到了end就直接退出。此时return的就是当前的层数。

BFS的层数计算的话，我习惯于用一个空串作为哨兵，但是这样循环的判断条件就要变成q.size() > 1.

1320ms，好慢，还是通过了。

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        if (dict.empty()) return 0;
        if (start.empty() || end.empty()) return 0;
        if (start.length() != end.length()) return 0;
        dict.insert(end);
        
        queue<string> q;
        q.push(start);
        q.push("");
        int n = start.length();
        
        int h = 1;
        while (q.size() > 1) {
            string tmp = q.front();
            q.pop();
                
            if (tmp.empty()) { h++; q.push(""); continue;}
            
            for (int i = 0; i < n; ++i) {
                for (char c = 'a'; c <= 'z'; ++c) {
                    string next(tmp);
                    next[i] = c;
                    if (next == end) return h + 1;
                    if (next != tmp && dict.find(next) != dict.end()) {
                        q.push(next);
                        dict.erase(next);
                    }
                }
            }
        }
        
        return 0;
    }
};

 优化

1. 将第23行(string next(tmp))提到外循环，可以从1320ms降到900ms。

2. 将层数的判断用一个endOfLayer来判断，循环条件改回!q.empty()，可以再降到856ms。

3. 不要判断next != tmp（Line 26)，而是用tmp[i]  == c 里 直接continue; 再降到740ms。

4. 将return h + 1;放在dict.find找到之后再判断； 再降到620ms。

5. 将dict.find改成dict.count(next) > 0。降到460ms。

这首题是第一次尝试一步一步地优化，在内循环里面的每一个判断，每一步计算都要仔细考虑，这样才能达到更优。

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        if (dict.empty()) return 0;
        if (start.empty() || end.empty()) return 0;
        if (start.length() != end.length()) return 0;
        dict.insert(end);
        
        queue<string> q;
        q.push(start);
        string endOfLayer = start;
        int n = start.length();
        
        int h = 1;
        while (!q.empty()) {
            string tmp = q.front();
            q.pop();
            
            for (int i = 0; i < n; ++i) {
                string next(tmp);
                for (char c = 'a'; c <= 'z'; ++c) {
                    if (tmp[i] == c) continue;
                    next[i] = c;
                    
                    if (dict.count(next) > 0) {
                        if (next == end) return h + 1;
                        q.push(next);
                        dict.erase(next);
                    }
                }
            }
            
            if (endOfLayer == tmp) {
                endOfLayer = q.back();
                h++;
            }
        }
        
        return 0;
    }
};

 

Method II

从网上看到有人用两个vector来模拟queue的层数变换。

480ms

class Solution {
public:
    int ladderLength(string start, string end, unordered_set<string> &dict) {
        if (dict.empty()) return 0;
        if (start.empty() || end.empty()) return 0;
        if (start.length() != end.length()) return 0;
        dict.insert(end);
        
        vector<unordered_set<string> > layers(2);
        int cur = 0, pre = 1;
        layers[pre].insert(start);
        dict.erase(start);
        
        int n = start.length();
        
        int h = 1;
        while (!layers[pre].empty()) {
            layers[cur].clear();           
            for (unordered_set<string>::iterator it = layers[pre].begin(); it != layers[pre].end(); ++it) {
                for (int i = 0; i < n; ++i) {
                    string next(*it);
                    for (char c = 'a'; c <= 'z'; ++c) {
                        if ((*it)[i] == c) continue;
                        next[i] = c;
                        
                        if (dict.count(next) > 0) {
                            if (next == end) return h + 1;
                            layers[cur].insert(next);
                            dict.erase(next);
                        }
                    }
                }
            }
            
            cur = !cur;
            pre = !pre;
            h++;
        }
        
        return 0;
    }
};

 

Bug

另外，我尝试过queue里面保存的是unorder_set<string>::iterator，在本地主机上测试可以，在OJ上就runtime error了。第二天仔细一想，原来是真有bug。

见以下代码：

int ladderLength(string start, string end, unordered_set<string> &dict) {
        if (dict.empty()) return 0;
        if (start.empty() || end.empty()) return 0;
        if (start.length() != end.length()) return 0;
        dict.insert(start);
        dict.insert(end);
        
        queue<unordered_set<string>::iterator> q;
        q.push(dict.find(start));
        q.push(dict.end());
        int n = start.length();
        
        int h = 1;
        while (q.size() > 1) {
            unordered_set<string>::iterator t = q.front();
            q.pop();
                
            if (t == dict.end()) { h++; q.push(dict.end()); continue;}
            string tmp(*t);
            dict.erase(t);
            
            for (int i = 0; i < n; ++i) {
                for (char c = 'a'; c <= 'z'; ++c) {
                    string next(tmp);
                    next[i] = c;
                    if (end == tmp) return h;
                    if (next == tmp) continue;
                    unordered_set<string>::iterator it = dict.find(next);
                    if (it != dict.end()) {
                        q.push(it);
                    }
                }
            }
        }
        
        return 0;
    }

首先用指针的话，那么就只能在pop queue的时候erase了（Line 20）。如果有两个word 'a' 和'b'，他们都能一步到达'c'，那么第一次的时候，那么'c'就会被插入队列两次。因此，'c'对应的这个指针也就会被erase两次！！！当然就是runtime error了。

不晓得为什么本地主机这么个bug都没有重现出来。。。。。。