给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict,判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
说明:
拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。
示例 1:
输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。
示例 2:
输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
输出: true
解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。
注意你可以重复使用字典中的单词。
示例 3:
输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
输出: false
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/word-break。
这道题目可以采用递归的方法进行求解。从字符串的首字符开始,依次向后遍历,当找到存在于字典当中的单词时,将其拆分为单词+字符串,然后递归对所得字符串求解。但是单纯这样去求解会有大量的重复极速三,造成超时的问题,故我们可以加入数组memory来保存已经计算的结果,每次计算前可以看是否存在于memory中,存在则不需要再次计算。 memory[start] 表示字符串 [i, n] 是否可拆分。
wordDict: cat, cats, and, sand, dog
s : catsanddog 长为10
第一层:
start = 0
\quad\quad\quad i = 1 \quad c
\quad\quad\quad i = 2 \quad ca
\quad\quad\quad i = 3 \quad cat 存在 ③返回1
\quad\quad\quad 第二层 :
\quad\quad\quad start = 3
\quad\quad\quad\quad\quad\quad i = 4 \quad s
\quad\quad\quad\quad\quad\quad i = 5 \quad sa
\quad\quad\quad\quad\quad\quad i = 6 \quad san
\quad\quad\quad\quad\quad\quad i = 7 \quad sand 存在 ②返回1
\quad\quad\quad\quad\quad\quad 第三层 :
\quad\quad\quad\quad\quad\quad start = 7
\quad\quad\quad\quad\quad\quad\quad\quad\quad i = 8 \quad d
\quad\quad\quad\quad\quad\quad\quad\quad\quad i = 9 \quad do
\quad\quad\quad\quad\quad\quad\quad\quad\quad i = 10 \quad dog 存在 ①返回1
返回结果顺序为①->②->③,最终结果为true。
class Solution {
public:
bool wordBreak(string s, vector<string>& wordDict) {
if(s.empty())
return true;
if(wordDict.empty())
return false;
int l = s.size();
// 方便后续查看对应单词在字典中是否存在
set<string> dict(wordDict.begin(),wordDict.end());
vector<int> memory(l,-1);
return fun(s,dict,memory,0);
}
bool fun(string s, set<string> dict, vector<int> &memory, int start)
{
if(start >= s.size())
return true;
if(memory[start] != -1)
return memory[start];
for(int i = start+1; i <= s.size(); i++)
{
if(dict.count(s.substr(start,i-start)) && fun(s,dict,memory,i))
return memory[start] = 1;
}
return memory[start] = 0;
}
};
复杂度:
时间复杂度: O(n^2) 。
空间复杂度: O(n) 。
这道题还可以用动态规划的方法去求解。
首先我们建立一个以为数组dp,其中dp[i]表示字符串[0,i)是否可以拆分,包含空字符串,故可以初始化dp[0] = true;
我们可以遍历字符串[0,i),将其分为两部分,[0,j) 以及[j, i),故可以得出动态转移方程为:
dp[i] = dp[j] && dict.count(s.substr(j,i-j))。
bool wordBreak(string s, vector<string>& wordDict) {
if(s.empty())
return true;
if(wordDict.empty())
return false;
int l = s.size();
set<string> dict(wordDict.begin(),wordDict.end());
vector<int> dp(l+1,0);
dp[0] = 1;
for(int i = 1; i <= l; i++)
{
for(int j = 0; j < i; j++)
{
if(dp[j] && dict.count(s.substr(j,i-j)))
{
dp[i] = 1;
break;
}
}
}
return dp[l];
}
复杂度:
时间复杂度: O(n^2) ;
空间复杂度: O(n) 。
上述我们采用了递归的方法对该问题进行了求解,实际上这就是DFS方法。
那么同样BFS应该也是可以求解的。
广度优先搜索法,也就是我们不会一次性直接遍历到最底端,而是每一步将整个字符串拆分为单词+字符串的形式,然后再继续对拆分得到的字符串进行判断(这里与DFS不同的是,DFS一旦找到一各符合要求的单词,便对后续的字符串进行求解,而BFS是先将当前可以得到的单词全部求解出来,然后分别求解各个单词对应的后续字符串)。建立一个queue,用于保存可拆分的位置。
这里我们可以建立一个memory数组,用于保存该位置是否拆分过。
举例说明:
wordDict: cat, cats, and, sand, dog
s : catsanddog 长为10
第一次循环:
q : 0;
start = 0
\quad\quad\quad i = 1 \quad c
\quad\quad\quad i = 2 \quad ca
\quad\quad\quad i = 3 \quad cat \quad q : 3
\quad\quad\quad i = 4 \quad cats \quad q : 3, 4
i = 5, 6, 7… …
第二次循环:
q : 3, 4
start = 3
\quad\quad\quad i = 4 \quad s
\quad\quad\quad i = 5 \quad sa
\quad\quad\quad i = 6 \quad san \quad
\quad\quad\quad i = 7 \quad sand \quad q : 4, 7
i = 7, 8 … …
第三次循环:
q : 4, 7
start = 4
\quad\quad\quad i = 5 \quad a
\quad\quad\quad i = 6 \quad an
\quad\quad\quad i = 7 \quad and \quad q : 7, 7
i = 8 , 9… …
第四次循环:
q : 7, 7
start = 7
\quad\quad\quad i = 8 \quad d
\quad\quad\quad i = 9 \quad do
\quad\quad\quad i = 10 \quad dog \quad q : 7, 10
这是 i = l,故返回true。
需要注意的一点是,在这个跟例子中如果还没有到字符串结尾,那么下一次循环中,start = 7,但显然这一种情况将会和第四次循环完全相同,属于重复计算,数组memory便是为了解决这个问题而存在的,我们将每一次拆分位置保存在memory当中,在每一次循环初,我们要首先判断该位置是否已经被处理过。
其广度搜索示意图如下:
bool wordBreak(string s, vector<string>& wordDict) {
if(s.empty())
return true;
if(wordDict.empty())
return false;
int l = s.size();
set<string> dict(wordDict.begin(),wordDict.end());
queue<int> q;
q.push(0);
vector<int> memory(l,0);
while(!q.empty())
{
int start = q.front();
q.pop();
if(memory[start])
continue;
for(int i = start+1; i <= l; i++)
{
if(dict.count(s.substr(start,i-start)))
{
q.push(i);
if(i == l)
return true;
}
}
memory[start] = 1;
}
return false;
}
复杂度:
时间复杂度: O(n^2) ;
空间复杂度: O(n) 。