【LeetCode & 剑指offer 刷题笔记】目录（持续更新中...）
Word Break（系列）
Word Break
Given a
non-empty
string
s
and a dictionary
wordDict
containing a list of
non-empty
words, determine if
s
can be segmented into a space-separated sequence of one or more dictionary words.
Note:
-
The same word in the dictionary may be reused multiple times in the segmentation.
-
You may a ssume the dictionary does not contain duplicate words.
Example 1:
Input:
s = "leetcode", wordDict = ["leet", "code"]
Output:
true
Explanation:
Return true because
"leetcode"
can be segmented as
"leet code"
.
Example 2:
Input:
s =
"applepenapple", wordDict = ["apple", "pen"]
Output:
true
Explanation:
Return true because
"
applepenapple
"
can be segmented as
"
apple pen apple
"
.
Note that you are allowed to reuse a dictionary word.
Example 3:
Input:
s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
Output:
false
/*
问题：拆分词句，看给定的词句能分被拆分成字典里面的内容
方法：动态规划
f[i]
表示s[0,i-1]是否可以被分词
,表示在第i个字符后面的隔板
状态转移方程：f(i) = any_of(f(j)&&s[j,i-1] ∈ dict); j = 0~i-1
例：
Input: s = "leetcode", wordDict = ["leet", "code"]
f[0] = true
i=1,j=0: l
i=2,j=0: le
j=1: e
i=3,j=0: lee
j=1: ee
j=2: e
i=4,j=0: leet f[4] = true
j=1: eet
j=2: et
j=3: t
...
O(n^2)
假设总共有n个字符串，并且字典是用HashSet来维护，那么总共需要n次迭代，每次迭代需要一个取子串的O(i)操作，然后检测i个子串，而检测是constant操作。所以总的时间复杂度是O(n^2)（i的累加仍然是n^2量级），而空间复杂度则是字符串的数量，即O(n)(本题还需加上字典的空间)
*/
class
Solution
{
public
:
bool
wordBreak
(
string s
,
vector
<
string
>
&
wordDict
)
{
unordered_set
<
string
>
new_dict
(
wordDict
.
begin
(),
wordDict
.
end
());
//转化为哈希表，方便查找
//长度为n的字符串有n+1个隔板，多分配一个空间以方便后续递推
vector
<
bool
>
f
(
s.size() + 1
,
false
);
f
[
0
]
=
true
;
// 空字符串，初始化为true,以便后续迭代
for
(
int
i
=
1
;
i
<
f
.
size
();
i
++)
//以s[i-1]字符结尾的子串, i=1~n
{
for
(
int
j
=
0
;
j
<
i
;
j
++)
//以s[j]开头的子串，j=0~i-1
{
if (f[j] &&
new_dict
.
find
(
s
.
substr
(
j
,
i
-
j
))
!=
new_dict
.
end
())
//substr[start,len)
{
f
[i] = true;
break
;
}
}
}
return
f[s.size()];
}
};
Word Break II
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:
[]
/*
问题：拆分词句2，返回所有分隔结果
方法：dfs
联系排列组合问题
这里用一个hash表避免对相同子串s进行重复分隔，减少重复计算
*/
class
Solution
{
public
:
vector
<
string
>
wordBreak
(
string s
,
vector
<
string
>&
wordDict
)
{
unordered_map
<
string
,
vector
<
string
>>
m
;
return
dfs
(
s
,
wordDict
,
m
);
}
vector
<
string
>
dfs
(
string s
,
vector
<
string
>&
wordDict
,
unordered_map
<
string
,
vector
<
string
>>&
m
)
{
if
(
m
.
find
(
s
)
!=
m
.
end
())
return
m
[
s
];
//如果对s的分隔已经递归过了，就直接退出
if
(
s
.
empty
())
return
{
""
};
//map型数据类型用{}，递归的出口
vector
<
string
>
res
;
//某一次的分隔结果
for
(
string word
:
wordDict
)
//遍历字典中的单词（递归的分支）
{
if
(
word
==
s
.
substr
(
0
,
word
.
size
())
)
//如果当前单词在s开头
{
//substr 返回子串 [pos, pos+count) 。若请求的子串越过 string 的结尾，或若 count == npos ，则返回的子串为 [pos, size())
vector
<
string
>
rem
=
dfs
(
s
.
substr
(
word
.
size
()),
wordDict
,
m
);
//对该单词后面的子串递归（分支的深度）,返回后面子串的分隔结果
for
(
string str
:
rem
)
//拼接后面子串的分隔结果与当前单词
{
res
.
push_back
(
word
+
(
str
.
empty
()
?
""
:
" "
)
+
str
);
//将word和str push到结果向量中，中间用空格隔开，此为某一种结果
}
}
}
return
m
[
s
]
=
res
;
//返回对s的分隔结果
}
};