1. 单词拆分
(1)DFS
最容易想到的就是回溯了,找到每个子串,逐一判断是否存在于字典中
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
return dfs(s, wordDict, 0);
}
//startIndex表示的是从字符串s的哪个位置开始
public boolean dfs(String s, List<String> wordDict, int startIndex) {
//字符串中的所有字符都遍历完了,也就是到叶子节点了,说明字符串s可以拆分成
//在字典中出现的单词,直接返回true
if (startIndex == s.length())
return true;
//开始拆分字符串s,
for (int i = startIndex + 1; i <= s.length(); i++) {
//如果截取的子串不在字典中,继续截取更大的子串
if (!wordDict.contains(s.substring(startIndex, i)))
continue;
//如果截取的子串在字典中,继续剩下的拆分,如果剩下的可以拆分成
//在字典中出现的单词,直接返回true,如果不能则继续
//截取更大的子串判断
if (dfs(s, wordDict, i))
return true;
}
return false;
}
}
(1)DFS优化
我们会发现超时了,这是因为如果字符串s比较长的话,这里会包含大量的重复计算
所以这里可以考虑用备忘录算法优化一下
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
return dfs(s, wordDict, new HashSet<>(), 0);
}
public boolean dfs(String s, List<String> wordDict, Set<Integer> indexSet, int startIndex) {
//字符串都拆分完了,返回true
if (startIndex == s.length())
return true;
for (int i = startIndex + 1; i <= s.length(); i++) {
//如果已经判断过了,就直接跳过,防止重复判断
if (indexSet.contains(i))
continue;
//截取子串,判断是否是在字典中
if (wordDict.contains(s.substring(startIndex, i))) {
if (dfs(s, wordDict, indexSet, i))
return true;
//标记为已判断过
indexSet.add(i);
}
}
return false;
}
}
(2)BFS
思路与DFS基本一致,只需要使用一个队列记录每一层需要记录的值即可。BFS中在截取的时候,如果截取的子串存在于字典中,我们就要记录截取的位置,到下一层的时候就从这个位置的下一个继续截取
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
//这里为了提高效率,把list转化为set,因为set的查找效率要比list高
Set<String> setDict = new HashSet<>(wordDict);
//记录当前层开始遍历字符串s的位置
Queue<Integer> queue = new LinkedList<>();
queue.add(0);
int length = s.length();
while (!queue.isEmpty()) {
int index = queue.poll();
//如果字符串到遍历完了,自己返回true
if (index == length)
return true;
for (int i = index + 1; i <= length; i++) {
if (setDict.contains(s.substring(index, i))) {
queue.add(i);
}
}
}
return false;
}
}
(2)BFS(优化)
跟DFS一样,直接BFS也包含了大量重复计算
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
Set<String> setDict = new HashSet<>(wordDict);
//记录当前层开始遍历字符串s的位置
Queue<Integer> queue = new LinkedList<>();
queue.add(0);
int length = s.length();
//记录访问过的位置,减少重复判断
boolean[] visited = new boolean[length];
while (!queue.isEmpty()) {
int index = queue.poll();
//如果字符串都遍历完了,直接返回true
if (index == length)
return true;
//如果被访问过,则跳过
if (visited[index])
continue;
//标记为访问过
visited[index] = true;
for (int i = index + 1; i <= length; i++) {
if (setDict.contains(s.substring(index, i))) {
queue.add(i);
}
}
}
return false;
}
}
(3)动规
- 定义dp[i]表示字符串的前i个字符经过拆分是否都存在于字典wordDict中。
- 如果要求dp[i],我们需要往前截取k个字符,判断子串[i-k+1,i]是否存在于字典wordDict中,并且前面[0,i-k]子串拆分的子串也是否都存在于wordDict中,如下图所示
前面[0,i-k]子串拆分的子串是否都存在于wordDict中只需要判断dp[i-k]即可,而子串[i-k+1,i]是否存在于字典wordDict中需要查找,所以动态规划的递推公式很容易列出来
dp[i] = dp[i-k] && dict.contains(s.substring(i - k, i));
这个k我们需要一个个枚举:
class Solution {
public boolean wordBreak(String s, List<String> dict) {
boolean[] dp = new boolean[s.length() + 1];
for (int i = 1; i <= s.length(); i++) {
//枚举k的值
for (int k = 0; k <= i; k++) {
//如果往前截取全部字符串,我们直接判断子串[0,i-1]
//是否存在于字典wordDict中即可
if (k == i) {
if (dict.contains(s.substring(0, i))) {
dp[i] = true;
continue;
}
}
//递推公式
dp[i] = dp[i - k] && dict.contains(s.substring(i - k, i));
//如果dp[i]为true,说明前i个字符串结果拆解可以让他的所有子串
//都存在于字典wordDict中,直接终止内层循环,不用再计算dp[i]了。
if (dp[i]) {
break;
}
}
}
return dp[s.length()];
}
}