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