链接: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;
}
};