leetcode word_ladderII

最新推荐文章于 2019-12-16 18:17:01 发布

原创最新推荐文章于 2019-12-16 18:17:01 发布 · 110 阅读

0 ·

CC 4.0 BY-SA版权

算法同时被 2 个专栏收录

94 篇文章

订阅专栏

leetcode

50 篇文章

订阅专栏

本文介绍了一种寻找两个单词间最短转换路径的算法，通过仅改变一个字母的方式，并确保每一步转换后的单词都在给定的词典中存在。文章详细解释了使用递归和广度优先搜索两种方法实现该算法的过程。

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> > resres;
        if (start == end)
            return resres;
        int Res = INT_MAX;
        vector<bool> bvec(dict.size(), false);
        vector< vector<string> > res;
        
        vector<string> tmp;
        tmp.push_back(start);
        Find(start, end, dict, bvec, res, tmp);
        for(int i=0;i<res.size();i++)
        {
            Res = Res < res[i].size()?Res:res[i].size();
        }
        for(int i=0;i<res.size();i++)
        {
            if (Res == res[i].size())
                resres.push_back(res[i]);
        }
        return resres;
    }
    void Find(string cur, string end, unordered_set<string> &dict, vector<bool> &bvec, vector< vector<string> > &res, vector<string> &tmp)
    {
        if (IfOneDiff(cur,end))
        {
            tmp.push_back(end);
            res.push_back(tmp);
            tmp.pop_back();
        }
        unordered_set<string> ::iterator  iter = dict.begin();
        for (int i=0;i<dict.size();i++,iter++)
        {
            if (!bvec[i] && IfOneDiff(cur, *iter))
            {
                tmp.push_back(*iter);
                bvec[i] = true;
                Find(*iter, end, dict, bvec, res, tmp);
                bvec[i] = false;
                tmp.pop_back();
            }
        }
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};


//BFS  本地和答案一样  但是测试顺序不同

class Solution {
public:
    vector<vector<string> >findLadders(string start, string end, unordered_set<string> &dict) 
    {
        vector<vector<string> > res;
        queue<vector<string> > que;
        que.push(vector<string> (1,start));
        unordered_set<string> ::iterator  it = dict.find(start);
        if (it != dict.end())
            dict.erase(it);
        while(!que.empty())
        {
            int size = que.size();
            bool flag = false;
            for (int j = 0;j<size;j++)
            {
                vector<string> tmp =  que.front();
                que.pop();
                if (IfOneDiff(tmp.back(), end)) 
                {
                    flag = true;
                    res.push_back(tmp);
                    res.back().push_back(end);
                }
                if (!flag)
                {
                    for (unordered_set<string> ::iterator  iter = dict.begin();iter!=dict.end();)
                    {
                        if (IfOneDiff(tmp.back(), *iter))
                        {
                            que.push(tmp);
                            que.back().push_back(*iter);
                            dict.erase(iter++);//一定要删除  不然内存超过限制
                        }
                        else
                            iter++;
                    }
                }
            }
        }
        return res;
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

测试


#include "head.h"
class Solution1 {
public:
    vector<vector<string>> findLadders(string start, string end, unordered_set<string> &dict) 
    {
        vector< vector<string> > resres;
        if (start == end)
            return resres;
        int Res = INT_MAX;
        vector<bool> bvec(dict.size(), false);
        vector< vector<string> > res;
        
        vector<string> tmp;
        tmp.push_back(start);
        Find(start, end, dict, bvec, res, tmp);
        for(int i=0;i<res.size();i++)
        {
            Res = Res < res[i].size()?Res:res[i].size();
        }
        for(int i=0;i<res.size();i++)
        {
            if (Res == res[i].size())
                resres.push_back(res[i]);
        }
        return resres;
    }
    void Find(string cur, string end, unordered_set<string> &dict, vector<bool> &bvec, vector< vector<string> > &res, vector<string> &tmp)
    {
        if (IfOneDiff(cur,end))
        {
            tmp.push_back(end);
            res.push_back(tmp);
            tmp.pop_back();
        }
        unordered_set<string> ::iterator  iter = dict.begin();
        for (int i=0;i<dict.size();i++,iter++)
        {
            if (!bvec[i] && IfOneDiff(cur, *iter))
            {
                tmp.push_back(*iter);
                bvec[i] = true;
                Find(*iter, end, dict, bvec, res, tmp);
                bvec[i] = false;
                tmp.pop_back();
            }
        }
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

class Solution {
public:
    vector<vector<string> >findLadders(string start, string end, set<string> &dict) 
    {
        vector<vector<string> > res;
        queue<vector<string> > que;
        que.push(vector<string> (1,start));
        set<string> ::iterator  it = dict.find(start);
        if (it != dict.end())
            dict.erase(it);
        while(!que.empty())
        {
            int size = que.size();
            bool flag = false;
            for (int j = 0;j<size;j++)
            {
                vector<string> tmp =  que.front();
                que.pop();
                if (IfOneDiff(tmp.back(), end)) 
                {
                    flag = true;
                    res.push_back(tmp);
                    res.back().push_back(end);
                }
                if (!flag)
                {
                    for (set<string> ::iterator  iter = dict.begin();iter!=dict.end();)
                    {
                        if (IfOneDiff(tmp.back(), *iter))
                        {
                            que.push(tmp);
                            que.back().push_back(*iter);
                            dict.erase(iter++);
                        }
                        else
                            iter++;
                    }
                }
            }
        }
        return res;
    }
    bool IfOneDiff(string s1, string s2)
    {
        if (s2.size() != s2.size())
            return false;
        int size = 0;
        for (int i=0;i<s1.size();i++)
        {
            if(s1[i] != s2[i])
                if (++size > 1)
                    return false;
        }
        return size == 1;
    }
};

int main()
{
    Solution s;
    set<string> dict;
    //["hot","dot","dog","lot","log"]["hot","cog","dot","dog","hit","lot","log"]
    dict.insert("hot");
    dict.insert("cog");
    dict.insert("dot");
    dict.insert("dog");
    dict.insert("hit");
    dict.insert("lot");
    dict.insert("log");
    vector<vector<string> > res = s.findLadders("hit", "cog", dict);
    print2Dvectorint(res);
}