[leetcode]140. Word Break II

链接：https://leetcode.com/problems/word-break-ii/description/

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. Return all such possible sentences.

Note:

• The same word in the dictionary may be reused multiple times in the segmentation.
• You may assume the dictionary does not contain duplicate words.

Example 1:

Input:
s = "catsanddog"
wordDict = ["cat", "cats", "and", "sand", "dog"]
Output:
[
  "cats and dog",
  "cat sand dog"
]

Example 2:

Input:
s = "pineapplepenapple"
wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
Output:
[
  "pine apple pen apple",
  "pineapple pen apple",
  "pine applepen apple"
]
Explanation: Note that you are allowed to reuse a dictionary word.

Example 3:

Input:
s = "catsandog"
wordDict = ["cats", "dog", "sand", "and", "cat"]
Output:
[]

class Solution {
public:
    vector<string> wordBreak(string s, vector<string>& wordDict) {
        if (m.count(s)) return m[s];
        if (s.empty())  return {""};
        vector<string> res;
        for (string word : wordDict) {
            if (s.substr(0, word.size()) != word) continue;
            for (string r : wordBreak(s.substr(word.size()), wordDict)) {
                res.push_back(word + (r.empty() ? "" : " ") + r);
            }
        }
        return m[s] = res;
    }
private:
    unordered_map<string, vector<string>> m;
};

此题是Word Break 的升级版，Word  Break的思路见[leetcode]139. Word Break_xiaocong1990的博客-CSDN博客。

下面是Word  Break II的答案，是根据Word Break的思路改造得来。然而遇到

s="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

wordDict = ["a","aa","aaa","aaaa","aaaaa","aaaaaa","aaaaaaa","aaaaaaaa","aaaaaaaaa","aaaaaaaaaa"]

这类输入会超时。

class Solution {
public:
    vector<string> wordBreak(string s, vector<string>& wordDict)
    {
        unordered_set<string> dict(wordDict.begin(),wordDict.end());
        vector<bool> possible(s.size()+1, false);
        possible[0]=true;
 
        vector<string> ans;
        string item;
        dfs(s,dict,1,possible, ans, item);
        return ans;
 
    }
 
    void dfs(string&s, unordered_set<string>& dict, int idx,vector<bool>&possible, vector<string>& ans,string& item )
    {
        if(possible[s.size()]==true)
        {
 
            ans.push_back(item.substr(0, item.size()-1));
            return;
        }
        for (int i = idx; i<=s.size(); ++i)
        {
 
            for (int j=i-1;j>=idx-1;j--)
            {
 
                if(possible[j])
                {
                    string word = s.substr(j, i - j);
 
                    if (dict.find(word) != dict.end())
                    {
                        item += (word + " ");
                        possible[i]=true;
                        dfs(s, dict, i + 1, possible, ans, item);
 
                        possible[i] = false;
                        item.resize(item.size() - word.size() - 1);
                    }
                }
 
            }
 
        }
    }
};

其实在回溯、递归的过程中，有很多重复的计算。如果能去除这些重复的计算，那么就能大大提高速度。因此，我们可以在计算过程中，记录下每个字符串对应的答案，再次遇到的时候只要查一下就行了。因此可以改成如下：

---

class Solution {
public:
    vector<string> wordBreak(string s, vector<string>& wordDict)
    {
        map<string,vector<string>> ans;
        return dfs(s,wordDict,ans);
    }

    vector<string> dfs(string s, vector<string>& dict, map<string,vector<string>> ans)
    {
        if(ans.count(s) > 0)
            return ans[s];
        if(s.empty())
            return {""};
        vector<string> vec;

        for(auto word : dict)
        {
            int len=word.size();
            if(s.substr(0,len)!=word)
                continue;
            vector<string> sub_vec=dfs(s.substr(len),dict,ans);
            for(auto item : sub_vec)
            {
                string t = word + (item==""?"" : " " + item);
                vec.push_back(t);

            }
        }
        ans[s] = vec;
        return vec;
    }
};

class Solution {
public:
    vector<string> wordBreak(string s, vector<string>& wordDict) 
    {
        unordered_set<string> dict(wordDict.begin(),wordDict.end());        
        vector<bool> possible(s.size()+1, true);
        vector<string> ans;
        string item;
        dfs(s,dict,0,possible, ans, item);
        return ans;
        
    }
    
    bool dfs(string&s, unordered_set<string>& dict, int idx,vector<bool>&possible, vector<string>& ans,string& item )
    {
        bool res = false;
        if(idx==s.size())
        {
           
            ans.push_back(item.substr(0, item.size()-1));
            return true;
        }
        for (int i = idx; i<s.size(); ++i) 
        {
            string word = s.substr(idx, i - idx + 1);

		    if (dict.find(word) != dict.end() && possible[i + 1])
            {
			    item += (word + " ");
			    if (dfs(s, dict, i + 1, possible, ans, item)) 
                    res = true;
			    else 
                    possible[i + 1] = false;
                item.resize(item.size() - word.size() - 1);
            }
        }
        return res;
    }
};