leetcode word-breakII

最新推荐文章于 2019-04-26 22:54:03 发布
最新推荐文章于 2019-04-26 22:54:03 发布
阅读量165 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pynash123/article/details/84572014
给定字符串`s`和一个单词字典`dict`，任务是在`s`中添加空格，形成由字典中有效单词组成的句子。返回所有可能的此类句子。例如，对于`s =“catsanddog”`和字典`dict = [“cat”, “cats”, “and”, “sand”, “dog”]`，解决方案包括[“cats and dog”, “cat sand dog”]。" 122723585,11421585,C++实现的坦克大战实战分享,"['C++', '游戏开发', '算法', '实战经验']

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.
Return all such possible sentences.
For example, given
s =“catsanddog”,
dict =[“cat”, “cats”, “and”, “sand”, “dog”].
A solution is[“cats and dog”, “cat sand dog”]

//word-breakI
class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        int len = s.size();
        if(s.size() == 0) return false;
        vector<bool> dp(len + 1, false);
        dp[len] = true;
        
        for(int i = len - 1; i >= 0; i--)
        {
            for(int j = i; j < len; j++)
            {
                string substr = s.substr(i, j - i + 1);
                if(dict.find(substr) != dict.end() && dp[j+1] == true)
                {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[0];
    }
};

//DFS  复杂度过大
class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) 
    {
        string str;
        vector<string> res;
        fun (s, dict, res, 0, str);
        return res;
    }
    void fun (string &s, unordered_set<string> &dict, vector<string> &res,  int start, string &str)
    {
        for (int i=start+1;i<=s.size();i++)
        {
            string tmp = s.substr(start, i-start);
            if (dict.find(tmp) != dict.end())
            {
                string tmp1 = str;
                str += tmp;
                str += " ";
                if (start + tmp.size() == s.size())
                    res.push_back(str);
                else
                    fun (s, dict, res, start + tmp.size(), str, flag);
                str = tmp1;
            }
        }
    }
};
//DFS  优化 复杂度过大
class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) 
    {
        string str;
        vector<string> res;
        vector<vector<bool> > flag (s.size()+1, vector<bool> (s.size(), false));
        for(int i=0;i<s.size();i++)
        {
            for (int j=i;j<s.size();j++)
            {
                string tmp = s.substr(i, j-i+1);
                if (dict.find(tmp) != dict.end())
                    flag[i][j] = true;
            }
        }
        
        fun (s, dict, res, 0, str, flag);
        return res;
    }
    void fun (string &s, unordered_set<string> &dict, vector<string> &res,  int start, string &str, vector<vector<bool> > &flag)
    {
        for (int i=start+1;i<=s.size();i++)
        {
            string tmp = s.substr(start, i-start);
            if (flag[start][i-1])
            {
                string tmp1 = str;
                str += tmp;
                str += " ";
                if (start + tmp.size() == s.size())
                    res.push_back(str);
                else
                    fun (s, dict, res, start + tmp.size(), str, flag);
                str = tmp1;
            }
        }
    }
};


//直接递归

class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) {
        return fun(s,dict);
    }
    vector<string> fun(string s, unordered_set<string> &dict)
    {
        vector<string> res;
        for (int i=0;i<s.size();i++)
        {
            string tmp = s.substr(0, i+1);
            if (dict.find(tmp) != dict.end())
            {
                if (i == s.size()-1)
                    res.push_back(tmp);
                else
                {
                    vector<string> vec = fun(s.substr(i+1), dict);
                    for (int j=0;j<vec.size();j++)
                    {
                        res.push_back(tmp);
                        res.back() += " ";
                        res.back() += vec[j];
                    }
                }
            }
        }
        return res;
    }
};


//递归保存   结果顺序不一样
class Solution {
public:
    vector<string> wordBreak(string s, unordered_set<string> &dict) 
    {
        if (mmap.find(s) != mmap.end())
            return mmap[s];
        vector<string> res;
        for (int i=0;i<s.size();i++)
        {
            string tmp = s.substr(0, i+1);
            if (dict.find(tmp) != dict.end())
            {
                if (i == s.size()-1)
                    res.push_back(tmp);
                else
                {
                    vector<string> vec = wordBreak(s.substr(i+1), dict);
                    for (int j=0;j<vec.size();j++)
                    {
                        res.push_back(tmp);
                        res.back() += " ";
                        res.back() += vec[j];
                    }
                }
            }
        }
        mmap.insert(pair<string, vector<string> >(s, res));
        return res;
    }
    map <string, vector<string> > mmap;
};

测试

#include "head.h"
class Solution1 {
public:
    bool wordBreak(string s, set<string> &dict) {
        int len = s.size();
        if(s.size() == 0) return false;
        vector<bool> dp(len + 1, false);
        dp[len] = true;
        
        for(int i = len - 1; i >= 0; i--)
        {
            for(int j = i; j < len; j++)
            {
                string substr = s.substr(i, j - i + 1);
                if(dict.find(substr) != dict.end() && dp[j+1] == true)
                {
                    dp[i] = true;
                    break;
                }
            }
        }
        print1Dvectorint(dp);
        return dp[0];
    }
};

class Solution2 {
public:
    vector<string> wordBreak(string s, set<string> &dict) 
    {
        string str;
        vector<string> res;
        fun (s, dict, res, 0, str);
        return res;
    }
    void fun (string &s, set<string> &dict, vector<string> &res,  int start, string &str)
    {
        for (int i=start+1;i<=s.size();i++)
        {
            string tmp = s.substr(start, i-start);
            if (dict.find(tmp) != dict.end())
            {
                string tmp1 = str;
                str += tmp;
                str += " ";
                if (start + tmp.size() == s.size())
                    res.push_back(str);
                else
                    fun (s, dict, res, start + tmp.size(), str);
                str = tmp1;
            }
        }
    }
};

class Solution3 {
public:
    vector<string> wordBreak(string s, set<string> &dict) 
    {
        string str;
        vector<string> res;
        vector<vector<bool> > flag (s.size()+1, vector<bool> (s.size(), false));
        for(int i=0;i<s.size();i++)
        {
            for (int j=i;j<s.size();j++)
            {
                string tmp = s.substr(i, j-i+1);
                if (dict.find(tmp) != dict.end())
                    flag[i][j] = true;
            }
        }
        
        fun (s, dict, res, 0, str, flag);
        return res;
    }
    void fun (string &s, set<string> &dict, vector<string> &res,  int start, string &str, vector<vector<bool> > &flag)
    {
        for (int i=start+1;i<=s.size();i++)
        {
            string tmp = s.substr(start, i-start);
            if (flag[start][i-1])
            {
                string tmp1 = str;
                str += tmp;
                str += " ";
                if (start + tmp.size() == s.size())
                    res.push_back(str);
                else
                    fun (s, dict, res, start + tmp.size(), str, flag);
                str = tmp1;
            }
        }
    }
};

class Solution4 {
public:
    vector<string> wordBreak(string s, set<string> &dict) {
        return fun(s,dict);
    }
    vector<string> fun(string s, set<string> &dict)
    {
        vector<string> res;
        for (int i=0;i<s.size();i++)
        {
            string tmp = s.substr(0, i+1);
            if (dict.find(tmp) != dict.end())
            {
                if (i == s.size()-1)
                    res.push_back(tmp);
                else
                {
                    vector<string> vec = fun(s.substr(i+1), dict);
                    for (int j=0;j<vec.size();j++)
                    {
                        res.push_back(tmp);
                        res.back() += " ";
                        res.back() += vec[j];
                    }
                }
            }
        }
        return res;
    }
};

class Solution {
public:
    vector<string> wordBreak(string s, set<string> &dict) 
    {
        if (mmap.find(s) != mmap.end())
            return mmap[s];
        vector<string> res;
        for (int i=0;i<s.size();i++)
        {
            string tmp = s.substr(0, i+1);
            if (dict.find(tmp) != dict.end())
            {
                if (i == s.size()-1)
                    res.push_back(tmp);
                else
                {
                    vector<string> vec = wordBreak(s.substr(i+1), dict);
                    for (int j=0;j<vec.size();j++)
                    {
                        res.push_back(tmp);
                        res.back() += " ";
                        res.back() += vec[j];
                    }
                }
            }
        }
        mmap.insert(pair<string, vector<string> >(s, res));
        return res;
    }
    map <string, vector<string> > mmap;
};
//["cat", "cats", "and", "sand", "dog"].
int main()
{
    Solution s;
    set<string> dict;
    dict.insert("cat");
    dict.insert("cats");
    dict.insert("and");
    dict.insert("sand");
    dict.insert("dog");
    vector<string> res = s.wordBreak("catsanddog", dict);
    print1Dvectorint(res);
}
python-leetcode题解之140-Word-Break-II
09-06
本篇内容专注于解决 LeetCode 上的第140号问题——Word Break II。这是一道涉及到字符串处理、递归、回溯以及动态规划的问题。问题的难点在于不仅要判断能否将给定字符串按给定字典进行拆分，还要输出所有可能的拆分...
js-leetcode题解之140-word-break-ii.js
最新发布
11-05
在解决"Word Break II"这一经典的编程问题时，LeetCode平台上的题解提供了一种使用JavaScript语言实现的解决方案。这个问题要求编程者设计一个算法，能够找出所有可能的单词断句方式，并返回这些断句方式组成的句子...
Leetcode Word Break II
架构设计
03-04 155
Word Break II Given a stringsand a dictionary of wordsdict, add spaces insto construct a sentence where each word is a valid dictionary word. Return all such possible sentences. For example...
LeetCode word-break
不可不戒
09-22 598
Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words. For example, given s =”leetcode”, dict =[“leet”, “co
leetcode word-break-ii(Java)
聚沙成塔
04-20 407
leetcode题目 word-break-ii 题目描述 * Given a string s and a dictionary of words dict, * add spaces in s to construct a sentence where each word is a valid dictionary word. * Return all such possible ...
LeetCode_Word Break II
loveRooney的专栏
07-06 834
在Word Break第一问的基础上，我们首先确定了在
leetcode之word-break-ii(动态规划)
此心光明，亦复何言~
04-26 396
题目 Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences. For example, given s =“catsa...
LeetCode题解 - Java语言实现-181页.pdf
06-04
5. Word Break II 单词断词II是一个变体的问题，要求将字符串断词为单词，并且可以使用动态规划或Trie树来解决该问题。 6. Word Ladder 单词梯是一个字符串问题，要求将一个单词转换为另一个单词，并且每次转换...
lrucacheleetcode-leetcode-in-go:leetcode-in-go
06-29
lru缓存leetcode Go 中解决的一些 Leetcode 问题 大批 3sum-0015 买卖股票的最佳时机-0121 最多水的容器-0011 contains-duplicate-0217 find-minimum-in-rotated-sorted-array-0153 ...word-break-0139 图形
leetcode338-coding_notebook:编码_笔记本
07-01
第 338 章概括 [（雅虎）4。...问题/数组和字符串/140.word_break_ii.md) [151. 反转字符串中的单词](Leetcode Problems/Array and String/151.reverse_words_in_a_string.md) [167. Two Sum 2 - In
[LeetCode]Word Break II
孙佰贵的专栏
11-20 1775
class Solution { //initialization problem will cause WA, because wordBreak whould be called several times for several cases in one instance //the whole memozation will also record the string which has
【Leetcode】Word Break II
业精于勤，荒于嬉
07-05 1029
题目链接：https://leetcode.com/problems/word-break-ii/ Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.Return all such po
LeetCode Word Break II
Dylan_Java_NYC的博客
09-13 536
原题链接在这里：https://leetcode.com/problems/word-break-ii/ 本题是Word Break的进阶题，要返回所有wordbreak的结果。 本题参照了这篇帖子：http://www.cnblogs.com/springfor/p/3877056.html 首先更具isWordBreak判断是否能拆，若能拆看从头到尾走，找到了一个wordDict里包含的
[leetcode]140. Word Break II
xiaocong1990的博客
06-04 410
链接：https://leetcode.com/problems/word-break-ii/description/ Given anon-emptystringsand a dictionarywordDictcontaining a list ofnon-emptywords, add spaces insto construct a sentence wh...
LeetCode 140. Word Break II（单词切分）
James Pan
05-27 2934
原题网址：https://leetcode.com/problems/word-break-ii/ Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word. Return al
leetcode Word Break II
zhidao_wenge的专栏
06-07 452
int length;     vector one_result;     vector result;     vector > is_word;          void backTrack(string &s, int last, int index, vector &one_result)     {         if(last == length)        
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值