leetcode—word ladder II

1.题目描述

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"]
  ]

2.解题思路

我一看到这个题目就觉得类似于最小生成树，应该用贪心算法来做，贪心算法的思路如下：

       从start串出发，找出一次变换可以得到的string串的集合S₁，如果集合S₁中包含有end串，那么搜索结束，否则，搜索两步之内能到达的串的集合S₂，同样判断两步之内能到达的串集合中是否有end串，以此类推，最终找到最短路径。另外，路径保存需要单独设置一个数据结构，

最终算法描述如下（类最小生成树）：

1. 将字典dict中的所有字符串分为左右两侧，一侧为leftside=start(实际编码不需存储)，一侧为rightside=(dict-start),当前距start最远的节点，比如说从start i 步之内可达的节点集合curStep = start （因为初始是0步可达）。
2. 计算nextStep，也就是 i+1 步可达的字符串集合，最简单的思路就是下面的思路，遍历curStep 遍历rightside，逐个比较，必然能找到nextStep，找到nextStep之后curStep 变成了nextStep,将nextStep 中的字符串从rightside里面抹去，nextStep清空继续寻找直至找到的nextStep或rightside为空（表示没有路径到end），或者end被发现。

于是有了下面的这份代码：

class Solution {
public:
    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
        // end typing your C/C++ solution below
        // DO NOT write int main() function
        //areslipan@163.com

        map<string,vector<string> > path;

        unordered_set<string>leftside;
        unordered_set<string>rightside=dict;
        rightside.insert(start);
        rightside.insert(end);

        leftside.insert(start);
        rightside.erase(start);

        unordered_set<string>curStep;
        unordered_set<string>nextStep;
        curStep.insert(start);
        while(curStep.find(end)==curStep.end()&&!rightside.empty())
        {

            unordered_set<string>::iterator iter_us_cur;
            unordered_set<string>::iterator iter_us_right;

            for(iter_us_cur=curStep.begin();iter_us_cur!=curStep.end();++iter_us_cur)
            {


                for(iter_us_right=rightside.begin();iter_us_right!=rightside.end();++iter_us_right)
                {

                    if(isCvtable(*iter_us_cur,*iter_us_right))
                    {
                        if(path.find(*iter_us_cur)!=path.end())
                        {
                            path[*iter_us_cur].push_back(*iter_us_right);
                        }
                        else
                        {
                            vector<string> emptyV;
                            path[*iter_us_cur]=emptyV;
                            path[*iter_us_cur].push_back(*iter_us_right);
                        }

                        nextStep.insert(*iter_us_right);
                    }
                }

            }

            if(nextStep.empty())break;
            for(iter_us_right=nextStep.begin();iter_us_right!=nextStep.end();++iter_us_right)
            {
                rightside.erase(*iter_us_right);
            }
            curStep = nextStep;
            nextStep.clear();
        }

        vector<vector<string> > result;
        vector<string> temp;

        if(curStep.find(end)!=curStep.end())
        {
            output(path,start,end,result,temp);
        }

        return result;

    }
    bool isCvtable(string str1,string str2)
    {
        //cout<<"isCvtable: "<<str1<<str2<<endl;
        if(str1.length()!=str2.length()){return false;}

        int count=0;
        for(int i = 0;i<str1.length();++i)
        {
            if(str1[i]!=str2[i])count++;
            if(count>1)return false;
        }

        return count==1;
    }


    void output(map<string,vector<string> >&path,string start,string end,vector<vector<string> >&result,vector<string> & temp)
    {
        temp.push_back(start);

        if(start==end)
        {
            result.push_back(temp);return;
        }

        vector<string>::iterator iter_v;

        for(iter_v=path[start].begin();iter_v!=path[start].end();++iter_v)
        {
            output(path,*iter_v,end,result,temp);temp.pop_back();
        }
    }
};

提交online judge之后，小数据集没问题，大数据集却TLE了，分析了一下，主要是从curStep求nextStep的过程太耗时，我这个是O(N²)的时间复杂度，结果如下：

挂掉的这个案例大概有3000个词，很大，分析了一下，题目给的参数是unordered_set是有用意的，unordered_set实际底层是个hash表，所以能够常数时间索引一个字符串，基于这个思路，在已知curStep、rightside求nextStep的过程中：

        对每一个curStep中的字符串，假设长度为M，那么它的每位有25种变化，也就是每个单词有25*M中变化，那么时间复杂度就变成了O(MN)，单词长度一般不会太大，所以这个是个线性的算法，分析完毕，我开始着手写算法：

class Solution {
public:
    vector<vector<string> > findLadders(string start, string end, unordered_set<string> &dict) {
        // end typing your C/C++ solution below
        // DO NOT write int main() function
        //areslipan@163.com

        map<string,vector<string> > path;

        unordered_set<string>rightside=dict;

        rightside.erase(start);

        unordered_set<string>curStep;
        unordered_set<string>nextStep;
        curStep.insert(start);
        while(curStep.find(end)==curStep.end()&&!rightside.empty())
        {
            unordered_set<string>::iterator iter_us_cur;
            for(iter_us_cur=curStep.begin();iter_us_cur!=curStep.end();++iter_us_cur)
            {
                string temp;
                for(int i=0;i<(*iter_us_cur).length();++i)
                {
                    for(int j = 0;j<26;j++)
                    {
                        temp = *iter_us_cur;
                        if(temp[i]!=('a'+j))
                        {
                            temp[i] = ('a'+j);
                        }

                        if(rightside.count(temp)==1)
                        {
                            nextStep.insert(temp);
                            if(path.find(*iter_us_cur)==path.end())
                            {
                                vector<string> emptyV;
                                path.insert(make_pair(*iter_us_cur,emptyV));
                            }

                            path[*iter_us_cur].push_back(temp);
                        }
                    }
                }
            }

            if(nextStep.empty())break;
            unordered_set<string>::iterator iter_set;
            for(iter_set=nextStep.begin();iter_set!=nextStep.end();++iter_set)
            {
                rightside.erase(*iter_set);
            }
            curStep = nextStep;
            nextStep.clear();
        }

        vector<vector<string> > result;
        vector<string> temp;

        if(curStep.find(end)!=curStep.end())
        {
            output(path,start,end,result,temp);
        }

        return result;

    }

    void output(map<string,vector<string> >&path,string start,string end,vector<vector<string> >&result,vector<string> & temp)
    {
        temp.push_back(start);

        if(start==end)
        {
            result.push_back(temp);return;
        }

        vector<string>::iterator iter_v;

        for(iter_v=path[start].begin();iter_v!=path[start].end();++iter_v)
        {
            output(path,*iter_v,end,result,temp);temp.pop_back();
        }
    }
};

结果出来的一瞬间很美妙：

另外，输出结果的方式也有改进的余地，如图所示，程序中的path实际是这么一张图，实际就是一张邻接表。

我的算法是从start开始深度搜索，直至找到end，当搜索到的最后一个节点不是end的时候其实都是无效搜索（而且比重很大），所以可以把上述这幅图反过来，然后从end开始反向搜索，以空间换时间。