LeetCode | Word Ladder II

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.

 从Word Ladder 这道题我们大概知道怎么做了。先用BFS遍历到end，顺便记录下每个节点的前置节点。最后用dfs把整条路径给输出来。

Word Ladder 中有两种方法，用方法一保存前置节点不知道为什么总会Memory Limit Exceeds.

后来仔细一想，其实和Word Ladder 中提到的bug一样，同层的点可能也是邻居（只差一个字符），那么一个点就会重复地被加入到queue里面，导致了pres数组增大。

用第二种方法就AC了。

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;
        bool found = false;
        while (!layers[pre].empty()) {
            for (unordered_set<string>::iterator it = layers[pre].begin(); it != layers[pre].end(); ++it) {
                dict.erase(*it);
            }
            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) found = true;
                            pres[next].push_back(*it);
                            
                            layers[cur].insert(next);
                        }
                    }
                }
            }
            
            cur = !cur;
            pre = !pre;
            h++;
            if (found) return h;
        }
        
        return 0;
    }
    
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        int min = ladderLength(start, end, dict);
        if (min == 0) return rets;
        
        vector<string> ret;
        build(start, end, ret);
        return rets;
    }
    
    void build(string &start, string end, vector<string> &ret) {
        if (end == start) {
            ret.insert(ret.begin(), start);
            rets.push_back(ret);
            ret.erase(ret.begin());
            return;
        }
        
        ret.insert(ret.begin(), end);
        for (vector<string>::iterator it = pres[end].begin(); it != pres[end].end(); ++it) {
            build(start, *it, ret);
        }
        ret.erase(ret.begin());
    }
    
private:
    unordered_map<string, vector<string> > pres;
    vector<vector<string> > rets;
};

 第三次刷，用了一个map使得每一层的string都惟一，去重。还有在build的时候，先反序地生成，最终再reverse过来，因为vector的头部插入的开销还是蛮大的。

AC, 664ms，相当快了。

class Solution {
public:
    bool findPath(string start, string end, unordered_set<string> &dict, unordered_map<string, vector<string> > &prev) {
        vector<vector<string> > layers(2);
        int cur = 0, next = 1, n = 1;
        layers[cur].push_back(start);
        dict.insert(end);
        
        bool flag = false;
        while (!layers[cur].empty()) {
            layers[next].clear();
            for (auto str: layers[cur]) {
                dict.erase(str);
            }
            unordered_map<string, bool> contained;
            
            for (auto str: layers[cur]) {
                if (str == end) break;
                for (int i = 0; i < str.length(); i++) {
                    string tmp(str);
                    for (char c = 'a'; c <= 'z'; c++) {
                        if (str[i] == c) continue;
                        tmp[i] = c;
                        if (dict.count(tmp) > 0) {
                            if (tmp == end) {
                                flag = true;   
                            }
                            if (contained.count(tmp) == 0) layers[next].push_back(tmp);
                            contained[tmp] = true;
                            prev[tmp].push_back(str);
                        }
                    }
                }
            }
            if (flag) break;
            cur = !cur; next = !next;
        }
        
        return flag;
    }
    
    void build(string start, string end, vector<vector<string> > &ans, 
                unordered_map<string, vector<string> > &prev, vector<string> &ret) {
            ret.push_back(end);
            if (end == start) {
                ans.push_back(ret);
            } else {
                for (auto str: prev[end]) {
                    build(start, str, ans, prev, ret);
                }
            }
            ret.pop_back();
    }
    
    void reverse(vector<string> &path) {
        for (int i = 0, j = path.size() - 1; i < j; i++, j--) swap(path[i], path[j]);    
    }
    
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        vector<vector<string> > ans;
        unordered_map<string, vector<string> > prev;
        
        if (!findPath(start, end, dict, prev)) return ans;
        
        vector<string> ret;
        build(start, end, ans, prev, ret);
        
        for (auto it = ans.begin(); it != ans.end(); it++) {
            reverse(*it);
        }
        return ans;
    }
};