Leetcode_word-ladder-ii

最新推荐文章于 2019-03-27 19:32:32 发布

fibo_nacci

最新推荐文章于 2019-03-27 19:32:32 发布

阅读量1.1k

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/flyupliu/article/details/26684851

版权

Leetcode 专栏收录该内容

155 篇文章

订阅专栏

本文介绍了一种使用广度优先搜索（BFS）解决单词转换问题的方法，目标是从一个起始单词转换到一个结束单词，同时确保每一步转换后的单词存在于给定的字典中。文中详细解释了算法实现过程，并提供了优化建议以避免内存限制错误。

摘要由CSDN通过智能技术生成

地址：https://oj.leetcode.com/problems/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 1的话这题思路应该有了，bfs可以构造最短路径。依旧用两个队列，一个保存当前处理的字符串，一个保存当前字符串的深度，一旦构造出一条路径，最短深度就可以求出。以后的bfs就可以根据最短长度来剪枝了。但是MLE了，嗯MLE好几次了。

网上参考了一份代码( http://yucoding.blogspot.com/2014/01/leetcode-question-word-ladder-ii.html ), 主要是两个unordered_set, 一个是当前bfs要遍历的所有节点集合curs，一个是下次bfs要遍历的节点nxts，在遍历过程中，记录每个单词的所有前驱单词(用于最后构造路径)，当检测到nxts中存在end时，说明已找到最短路径了，开始从end到start构建所有路径。

另外一个小细节是在bfs遍历过程中，遍历完curs后，在dict中删除curs中的所有元素，因为最短路径中一个单词只可能出现在某一层，既然在curs中出现了，就不应该在nxts中出现。这也避免了查重，节约了空间存储。

预处理也要注意一下，dict里插入start和end，不然要特殊判断，麻烦.

两次小改动AC，运行时间分别是1100ms+和1200ms+

参考代码

class Solution {
private:
    unordered_map<string, vector<string>>findlast;
    vector<vector<string>>ans;
public:
    void findnext(string cur, unordered_set<string>&dict, unordered_set<string>&nxts)
    {
        string nxt;
        for(int i = 0; i<cur.length(); ++i)
        {
            for(char ch = 'a'; ch<='z'; ++ch)
            {
                if(ch!=cur[i])
                {
                   nxt = cur;
                   nxt[i] = ch;
                   if(dict.find(nxt)!=dict.end())
                   {
                       findlast[nxt].push_back(cur);
                       nxts.insert(nxt);
                   }
                }
            }
        }
    }
    void bulitpath(vector<string>&vec, const string& start, const string& end)
    {
        if(end==start)
        {
            vector<string>v(vec.rbegin(), vec.rend());
            ans.push_back(v);
        }
    
        for(int i = 0; i<findlast[end].size(); ++i)
        {
            vec.push_back(findlast[end][i]);
            bulitpath(vec, start, findlast[end][i]);
            vec.pop_back();
        }
    }
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
        ans.clear();
        unordered_set<string>curs, nxts;
        curs.insert(start);
        dict.insert(start);
        dict.insert(end);
        vector<string>vec;
        vec.push_back(end);
        while(!curs.empty())
        {
            for(auto it = curs.begin(); it != curs.end(); ++it)
                dict.erase(*it);
            for(auto it = curs.begin(); it != curs.end(); ++it)
                findnext(*it, dict, nxts);

            if(nxts.find(end)!=dict.end())
            {
                bulitpath(vec, start, end);
                return ans;
            }

            curs = nxts;
            nxts.clear();
        }
        return ans;
    }
};