LeetCode127: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+DFS。首先如Word Ladder,构造抽象图,然后利用BFS找到从start到end的最短路径,但寻找最短路径的过程中,我们需要保持最短路径最个节点的父节点信息,以便之后进行所有最短路径结果的重构,重构路径采用的DFS回溯,从end节点开始一直到start节点。好了,不多说了,直接上代码。
  • 实现代码:(注:该代码未能AC,出现内存限制,忘牛人指正,实在不知错在哪里)
  • #include <iostream>
    #include <string>
    #include <vector>
    #include <queue>
    #include <unordered_set>
    #include <unordered_map>
    #include <algorithm>
    using namespace std;
    
    /**
    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.
    */
    
    class Solution {
    public:
        vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) {
            vector<vector<string>> resvec;
            if(start.empty() || end.empty() || dict.empty())
                return resvec;
            unordered_map<string, vector<string>> premap;
            //这里需要用到两个vector来模拟两个队列而不是直接用两个队列,是因为需要对队列进行遍历,queue做不到 
            vector<string> squ[2]; 
            squ[0].push_back(start);
            bool qid = false;
            bool finish = false;
            while(!squ[qid].empty())
            {
                squ[!qid].clear();
                vector<string>::iterator iter;
                for(iter = squ[qid].begin(); iter != squ[qid].end(); ++iter)
                    dict.erase(*iter);//从dict中删除同一层的所有节点,以免造成循环操作 
                for(iter = squ[qid].begin(); iter != squ[qid].end(); ++iter)//处理同一层节点 
                {
                    string curstr = *iter;                
                    for(int i = 0; i < curstr.size(); i++)
                    {
                        char t = curstr[i];
                        for(char j = 'a'; j <= 'z'; j++)
                        {
                            if(j == curstr[i])
                                continue;
                            curstr[i] = j;
                            if(curstr == end)
                            {
                                finish = true;
                                premap[curstr].push_back(*iter);
                                
                            }                            
                            else if(dict.count(curstr) > 0)
                            {
                                squ[!qid].push_back(curstr);
                                premap[curstr].push_back(*iter);
                            }
                        }
                        curstr[i] = t;
                        
                    }                                            
                }
                if(finish)//说明已经处理到了end节点,可以直接break循环,进行结果重构了 
                        break;            
                qid = !qid;//表示将要处理的下一层 
            }
            if(premap.count(end) == 0)//表明end节点的父节点不存在,所有没有到end的转换,直接返回空resvec 
                return resvec;
            vector<string> tmp;
            getResult(resvec, tmp, premap, start, end);
            return resvec;        
        }
        
    
        
        //DFS 
        void getResult(vector<vector<string> > &resvec, vector<string> &tmp,   
            unordered_map<string, vector<string> > &premap, string &start, string &cur)  
        {  
            tmp.push_back(cur);
            if (cur == start)  
            {  
                resvec.push_back(tmp);  
                reverse(resvec.back().begin(), resvec.back().end());    
            }
            else
            {
                vector<string> v = premap[cur];  
                for (int i = 0; i < v.size(); i++)  
                {   
                    getResult(resvec, tmp, premap, start, v[i]);  
                }            
            }  
            tmp.pop_back();  
        }
    };
    
    
    int main(void)
    {
        string start("hit");
        string end("cog");
        string strarr[] = {"hot","dot","dog","lot","log"};
        int n = sizeof(strarr) / sizeof(strarr[0]);
        unordered_set<string> dict(strarr, strarr+n);
        Solution solution;
        vector<vector<string>> resvec = solution.findLadders(start, end, dict);
        vector<vector<string>>::iterator iter;
        for(iter = resvec.begin(); iter != resvec.end(); ++iter)
        {
            vector<string> tmp = *iter;
            vector<string>::iterator it;
            for(it = tmp.begin(); it != tmp.end(); ++it)
                cout<<*it<<" ";
            cout<<endl;
        }
        return 0;
    }

    以下附网上大神AC代码一份:

    class Solution {
    public:
        vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict)
        {
            result_.clear();
            unordered_map<string, vector<string>> prevMap;
            for(auto iter = dict.begin(); iter != dict.end(); ++iter)
                prevMap[*iter] = vector<string>();
            vector<unordered_set<string>> candidates(2);
            int current = 0;
            int previous = 1;
            candidates[current].insert(start);
            while(true)
            {
                current = !current;
                previous = !previous;
                for (auto iter = candidates[previous].begin(); iter != candidates[previous].end(); ++iter)
                    dict.erase(*iter);
                candidates[current].clear();
                
                for(auto iter = candidates[previous].begin(); iter != candidates[previous].end(); ++iter)
                {
                    for(size_t pos = 0; pos < iter->size(); ++pos)
                    {
                        string word = *iter;
                        for(int i = 'a'; i <= 'z'; ++i)
                        {
                            if(word[pos] == i)continue;
                            word[pos] = i;
                            if(dict.count(word) > 0)
                            {
                                prevMap[word].push_back(*iter);
                                candidates[current].insert(word);
                            }
                        }
                    }
                }
                if (candidates[current].size() == 0)
                    return result_;
                if (candidates[current].count(end)) break;
            }
            vector<string> path;
            GeneratePath(prevMap, path, end);
            return result_;
        }
        
    private:
        void GeneratePath(unordered_map<string, vector<string>> &prevMap, vector<string>& path, const string& word)
        {
            if (prevMap[word].size() == 0)
            {
                path.push_back(word);
                vector<string> curPath = path;
                reverse(curPath.begin(), curPath.end());
                result_.push_back(curPath);
                path.pop_back();
                return;
            }
            path.push_back(word);
            for (auto iter = prevMap[word].begin(); iter != prevMap[word].end(); ++iter)
                GeneratePath(prevMap, path, *iter);
            path.pop_back();
        }
        vector<vector<string>> result_;
    };
    代码来源:http://blog.csdn.net/doc_sgl/article/details/13341405
    -----------------------我和我追猪的梦-----------------------------------------------------------------
      
    作者:mickole
    posted @ 2014-04-28 09:41  mickole  阅读(394)  评论(0编辑  收藏  举报