Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.
For example, given
s = "leetcode"
,
dict = ["leet", "code"]
.
Return true because "leetcode"
can be segmented as "leet code"
.
一看这题目,就感觉里面回溯法,因为这种题,在回溯法中在平常不过了。上代码:
public boolean wordBreak(String s, Set<String> wordDict) {
if (s == null || wordDict == null) return false;
return dfs(s, wordDict, 0);
}
private boolean dfs(String str, Set<String> wordDict, int s) {
if (s > str.length()) return false;
else if (s == str.length()) return true;
for (int i = s+1; i <= str.length(); i++) {
String sub = str.substring(s, i);
if (wordDict.contains(sub) && dfs(str, wordDict, i)) {
return true;
}
}
return false;
}
标准的回溯方法,但是超时。可以分析一下为什么超时,假设s="aaab",wordDict={"a", "aa", "aaa"};
看一看递归树:
a aa aaa aaab
a aa aab a ab b
a ab b b
b
可以看出重叠子问题,因为在没有找到匹配的时候,会全部遍历这课树,所以可以改用动态规划。
boolean[] can = new boolean[s.length()+1];
can[0] = true;// 空字符串
//f(0, i) = f(0, j) & f(j, i) k = 0...n-1; i = 0...n
for (int i = 1; i <= s.length(); i++) {
for (int j = 0; j < i; j++) {
if (can[j] && wordDict.contains(s.substring(j, i))) {
can[i] = true;
break;
}
}
}
return can[s.length()];
boolean数组can[i]是指,s.substring(0,i)是可以分割的,所示数组最后一个元素即为所求。
public boolean wordBreak(String s, Set<String> wordDict) {
boolean[] can = new boolean[s.length()+1];
can[s.length()] = true;
for (int i = s.length()-1; i >= 0; i--) {
for (int j = s.length(); j > i; j--) {
if (wordDict.contains(s.substring(i, j)) && can[j]) {
can[i] = true;
break;
}
}
}
return can[0];
}
另外一个版本,can[i]只值以i为起点的字符串是否在wordDict中
接下来搞word breakII
Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.
Return all such possible sentences.
For example, given
s = "catsanddog"
,
dict = ["cat", "cats", "and", "sand", "dog"]
.
A solution is ["cats and dog", "cat sand dog"]
.
因为要列出所有的可能,所以肯定要用dfs,一个很标准额DFS模板式解答:
public List<String> wordBreak(String s, Set<String> wordDict) {
List<String> list = new ArrayList<String>();
if (s == null || wordDict == null) return list;
dfs(list, s, wordDict, new StringBuilder(), 0);
return list;
}
private void dfs(List<String> list, String s, Set<String> dict, StringBuilder sb, int index) {
if (index == s.length()) {
list.add(new String(sb.toString()));
return;
}
for (int i = index+1; i <= s.length(); i++) {
StringBuilder temp = new StringBuilder(sb);
String sub = s.substring(index, i);
if (dict.contains(sub)) {
if (index != 0)
temp.append(" ");
temp.append(sub);
dfs(list, s, dict, temp, i);
}
}
}
很显然超时了,怎么办?在DFS中只能剪枝了,我们可以根据word break得出,我们可以先在O(n2)的空间复杂度下跑一下wordbreak,根据其can[]数据进行剪枝
public List<String> wordBreak(String s, Set<String> wordDict) {
List<String> list = new ArrayList<String>();
if (s == null || wordDict == null) return list;
dfs(list, s, wordDict, new StringBuilder(), check(s, wordDict), 0);
return list;
}
private void dfs(List<String> list, String s, Set<String> dict, StringBuilder sb, boolean[] can, int index) {
if (index == s.length()) {
list.add(new String(sb.toString()));
return;
}
for (int i = index+1; i <= s.length(); i++) {
String sub = s.substring(index, i);
StringBuilder temp = new StringBuilder(sb);
if (dict.contains(sub) && can[i]) {
if (index != 0)
temp.append(" ");
temp.append(sub);
dfs(list, s, dict, temp, can, i);
}
}
}
private boolean[] check(String s, Set<String> wordDict) {
boolean[] can = new boolean[s.length()+1];
can[s.length()] = true;
for (int i = s.length()-1; i >= 0; i--) {
for (int j = s.length(); j > i; j--) {
if (wordDict.contains(s.substring(i, j)) && can[j]) {
can[i] = true;
break;
}
}
}
return can;
}
在DFS的时候,不仅要保证subsring(i, j)在wordDic中,此时还要保证substring(j, length),此时效率要高很多,不错!