LeetCode Word Break & Word Break II

Word Break

题意：给定一个字符串str，和一个集合dict，问能否用集合当中的字符串（可以使用多次）拼接处str

解法：动态规划dp[i]表示当前i前面的下标能否被拼接而成

刚刚开始都会想到一个比较朴素的想法是

for (int i=1; i<=l; i++)

while (ite.hasNext())

……

但是后来发现貌似不用遍历dict，而是枚举任意两个的起始点和终点，然后判断当前这个字符串是否在dict当中出现过

for (int i=1; i<=l; i++)

for (int j=i-1;j>=0; j--)

……

两个方法都可以，但是明显第二个编写比较简单。复杂度上，第一个是O(L^2)，第二个是O(LM)，其中L是字符串的长度，而M是dict几何所包含的字符串个数。

import java.util.*;

public class Solution {
public boolean wordBreak(String s, Set<String> dict) {
int l = s.length();
boolean dp[] = new boolean[l + 1];
Arrays.fill(dp, false);
dp[0] = true;

for (int i = 1; i <= l; i++) {
for (int j = i - 1; j >= 0; j--) {
if (dp[j] && dict.contains(s.substring(j, i))) {
dp[i] = true;
}
}
}
return dp[l];
}

public static void main(String[] args) {
Solution s = new Solution();
String str = "abcde";
Set<String> dict = new HashSet<String>();
dict.add("a");
dict.add("abc");
dict.add("b");
dict.add("cd");
System.out.println(s.wordBreak(str, dict));
}
}

Word Break II

题意：比上一个返回条件复杂了一点，要求返回所以可能的情况……其实还是dp就可以
解法一：

第一种解法和上面的类似，还是dp，只不过用一个HashMap记录了一下当前所有情况的结果

代码如下（TLE了）

import java.util.*;

public class Solution {
public List<String> wordBreak(String s, Set<String> dict) {
int l = s.length();
boolean dp[] = new boolean[l + 1];
dp[0] = true;
HashMap<Integer, LinkedList<String>> map = new HashMap<Integer, LinkedList<String>>();
for (int i = 0; i <= l; i++)
map.put(i, new LinkedList<String>());
map.get(0).add("");

LinkedList<String> listI, listJ;
String first, second;
for (int i = 1; i <= l; i++) {
listI = map.get(i);
for (int j = i - 1; j >= 0; j--) {
if (dp[j] && dict.contains(s.substring(j, i))) {
dp[i] = true;
second = s.substring(j, i);
if (j == 0) {
listI.add(second);
} else {
listJ = map.get(j);
Iterator<String> ite = listJ.iterator();
while (ite.hasNext()) {
first = ite.next();
listI.add(first + " " + second);
}
}
}
}
}

return map.get(l);
}
}

解法二：

从前往后暴力搜索或者归溯法记忆化搜索，不过后者比较好费空间。

纯暴力在这里会TLE，可以先判断是否能够break，因为给的测试数据很多是不可行的，不过稍微有些赖皮的方法。

import java.util.*;

public class Solution {
public ArrayList<String> list;
public String string;
public Set<String> set;

public ArrayList<String> wordBreak(String s, Set<String> dict) {
list = new ArrayList<String>();
if (s == null || s.length() == 0)
return list;
if (!wordBreakOK(s, dict))
return list;
string = s;
set = dict;
dfs(0, "");
return list;
}

public boolean wordBreakOK(String s, Set<String> dict) {
int l = s.length();
boolean dp[] = new boolean[l + 1];
Arrays.fill(dp, false);
dp[0] = true;

for (int i = 1; i <= l; i++) {
for (int j = i - 1; j >= 0; j--) {
if (dp[j] && dict.contains(s.substring(j, i))) {
dp[i] = true;
}
}
}
return dp[l];
}

public void dfs(int start, String temp) {
if (start == string.length()) {
list.add(temp);
return;
}
for (int i = start + 1; i <= string.length(); i++) {
if (set.contains(string.substring(start, i))) {
if (start > 0)
dfs(i, temp + " " + string.substring(start, i));
else
dfs(i, string.substring(start, i));
}
}
}

public static void main(String[] args) {
Solution s = new Solution();
String str = "abcd";
Set<String> dict = new HashSet<String>();
dict.add("a");
dict.add("abc");
dict.add("b");
dict.add("cd");
dict.add("d");
System.out.println(s.wordBreak(str, dict));
}
}