Word Ladder II -- leetcode

Given two words (start and end), and a dictionary, find all shortest transformation sequence(s) from start to end, such that:

1. Only one letter can be changed at a time
2. 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.

基本思路：

要找出变化的最短路径，则需要进行一次广度优先搜索，以求得路径最小长度。

再进行一次深度优先搜索，以记录这些能达到目的地的路径。

从一个节点，找到它的邻接点时，通过将每位字符吕a-z逐一进行变化，然后在字典中查找是否存在。

在第一次广度优先搜索之时，记录下每个节点所在树的层次，即距离起始点的最小长度。

然后在深度优先搜索时，利用上面得到的信息。可以避免死循环，以及比淘汰比更短路径更长的路径。

因为每次找邻接点时，检查它是比本节点更上一层的接点。

深度优先搜索，开始与广度优先执行相反的方向。 即如果广度优先执行从start开始， 则深度从end开始。 即自底向上到顶。

因为达到层次1时，0层肯定就是start，无需再计算。 反之，从顶到底的话，因为底部不一定都是end。

而最好的方式，当是广度优先搜索，从end开始。 而深度则从start开始，这样的好处，是省去了最后路径的一个reverse操作。

下面 代码是BFS从start开始，故在最后路径，需要一个reverse操作。

在代码在 leetcode上实际执行时间为476ms。

class Solution {public:    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {        vector<vector<string>> ans;        vector<string> trace;        unordered_map<string, int> visited;        if (bfs(start, end, dict, visited))            dfs(start, end, visited, visited[end], trace, ans);                return ans;    }        bool bfs(string start, string end, const unordered_set<string> &dict, unordered_map<string, int> &visited) {        queue<string> q;        q.push(start);        int level = 0;        visited[start] = level;        bool found = false;        while (!found && !q.empty()) {            ++level;            int count = q.size();            while (count--) {                string word = q.front();                q.pop();                for (int i=0; i<word.size(); i++) {                    const char ch = word[i];                    for (char j='a'; j<='z'; j++) {                        word[i] = j;                        if (dict.find(word) != dict.end() && visited.find(word) == visited.end()) {                            q.push(word);                            visited[word] = level;                            if (word == end)                                found = true;                        }                    }                    word[i] = ch;                }            }        }        return found;    }        void dfs(const string &start, string &end, const unordered_map<string, int> &levelmap, int level, vector<string> &path, vector<vector<string>> &ans) {        auto iter = levelmap.find(end);        if (iter == levelmap.end() || iter->second != level) return;        if (level == 1) {            ans.push_back(path);            ans.back().push_back(end);            ans.back().push_back(start);            reverse(ans.back().begin(), ans.back().end());            return;        }                path.push_back(end);        for (int i=0; i<end.size(); i++) {            const char ch = end[i];            for (char j='a'; j<='z'; j++) {                end[i] = j;                dfs(start, end, levelmap, level-1, path, ans);            }            end[i] = ch;        }        path.pop_back();    }};

上面在BFS过程中，并未存储邻接点信息。即并未保持，树的父子关系。

在进行DFS过程中，邻接点仍需要进行重新计算。

偿试了一下，在BFS保存邻接点信息。每个结点保存了达到该结点的上一层的所有结点。

发现了BFS写起来要比上面复杂了。不再是那么单纯了: 那个visited，存入时间t和判断时间需要特殊考虑

虽然在visited上下了功夫，保证没有循环回路的产生；但无法避免同一层次结点之间的包含。

故在DFS搜索时，还是需要借助level递减这种方式，剔除，那些走了平行结点的路径。因为这些路径比最短路径要长。

此代码在leetcode上实际执行时间为1160ms。

大大的慢于上面的算法。 

而且空间利用比上面更多。

看来此算法不可取。

class Solution {public:    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {        vector<vector<string>> ans;        unordered_map<string, unordered_set<string>> tree;        vector<string> path;        int level;        if (bfs(start, end, dict, tree, level))            dfs(start, end, tree, path, level, ans);                    return ans;    }        bool bfs(string start, string end, const unordered_set<string> &dict, unordered_map<string, unordered_set<string>> &tree, int &level) {        unordered_set<string> visited;        queue<string> q;        q.push(end);        bool found = false;        level = 0;        while (!found && !q.empty()) {            int count = q.size();            ++level;            while (count--) {                string word = q.front();                q.pop();                if (visited.find(word) != visited.end())                    continue;                visited.insert(word);                const string parent = word;                for (int i=0; i<word.size(); i++) {                    const char ch = word[i];                    for (char j='a'; j<='z'; j++) {                        word[i] = j;                        if (dict.find(word) != dict.end() && visited.find(word) == visited.end()) {                            q.push(word);                            tree[word].insert(parent);                            if (word == start)                                found = true;                        }                    }                    word[i] = ch;                }            }        }        return found;    }        void dfs(string start, string end, unordered_map<string, unordered_set<string>> &tree, vector<string> &path, int level, vector<vector<string>> &ans) {        path.push_back(start);        if (start == end) {            ans.push_back(path);        }        else if (level) {            const auto &parents = tree[start];            for (auto p: parents) {                dfs(p, end, tree, path, level-1, ans);            }        }        path.pop_back();    }};