139. Word Break

题目：

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".

链接： http://leetcode.com/problems/word-break/

题解：

求字符串是否能被分为字典中的单词。这道题一上来就想到用DFS， 就是假如s.substring(0，i)可以在字典中被找到，那么接下来只需要看s.substring(i，len)  是否能在字典中被找到, 当s.length() = 0时便利完毕，返回true。需要注意的是DFS要remove掉字典中的单词，比如这个case : s = "aaaaaaa"， wordDict = {"aaa", "aaaa"}，假如不remove掉"aaa"，则结果不正确。 时间复杂度这个很有意思，因为自Java 7 update 6开始，string.substring()这个method的时间复杂度从O(1)变成了O(n), 以前是同一个char[]，现在会重新建立一个char[]。 所以下面解法的Time Complexity应该是O(n³)。也需要注意边界，因为substring方法得到的结果是前闭后开。 还看到discuss以及小莹子和code ganker使用dp来解决这道题，二刷时要好好参考一下。 (Time Complexity 这块我可能是错的，不少人说是O(2ⁿ)， 还要再好好分析)。WordBreak I和Word Break II一定要好好想清楚。

Time Complexity - O(n³)， Space Complexity - O(n²).

public class Solution {
    public boolean wordBreak(String s, Set<String> wordDict) {
        if(s == null || wordDict == null)
            return false;
        if(s.length() == 0)
            return true;
        int len = s.length();    

        for(int i = 1; i <= len; i++) {
            String frontPart = s.substring(0, i);
            String backPart = s.substring(i, len);
            if(wordDict.contains(frontPart)) {
                if(wordBreak(backPart, wordDict))
                    return true;
                wordDict.remove(frontPart);
            }
        }

        return false;
    }
}

二刷:

使用了dfs。这里我们比较容易就想到可以把这个大问题转换为子问题递归求解。

1. 先来看边界条件，当s == null或者 wordDict == null的时候，我们要返回false
2. 在字符串s长度为0的时候，这时候是计算完毕了所有的match，我们返回true。 (3/15/2016时 这道题好像少test case， 当s = ""并且dict = {"leet", "code"}的时候，系统抛出ArrayIndexOutofBoundsException异常

接下来我们从0开始遍历字符串， 我们把字符串分为两个部分，front 和 back，  front = s.substring(0, i + 1)， back = s.substring(i + 1)

1. 当dict中含有front的时候，我们递归求解，看是否wordBreak(back， wordDict)为true， 假如这个结果为true，我们直接返回true
2. 否则，说明我们这种split方法不对，我们这时候要做一个很给力的剪枝，wordDict.remove(front)，  把front这个单词从wordDict里面去除掉，免得后面继续做多余运算。
3. 遍历完字符串后依然没有返回true的话，我们返回false
4. 假如不算substring带来的cost的话，时间复杂度应该是O(n ^ 2)， 空间复杂度是在一个call stack里的小字符串长度综合，应该是O(n)。
5. 还有很多题友使用动态规划求解。 我自己的动态规划很烂，非常羡慕。

Java:

Time Complexity - O(n ^ 2)， Space Complexity - O(n)

public class Solution {
    public boolean wordBreak(String s, Set<String> wordDict) {
        if (s == null || wordDict == null) {
            return false;
        }
        if (s.equals("")) {
            return true;
        }
        for (int i = 0; i < s.length(); i++) {
            String substr = s.substring(0, i + 1);
            if (wordDict.contains(substr)) {
                if (wordBreak(s.substring(i + 1), wordDict)) {
                    return true;
                }
                wordDict.remove(substr);
            }
        }
        return false;
    }
}

dp:

建立一个boolean[]数组dp来保存结果，dp[i]表示到i这位我们是否满足分割成功。 初始化dp[0] = true。 使用一个双重循环来遍历字符串，每次假如满足条件dp[j] && s.substring(j, i)， 我们可以设置dp[i] = true，说明到i这一位的分割是成功的。 最后我们返回dp[len].

Time Complexity - O(n ^ 2)， Space Complexity - O(n)

public class Solution {
    public boolean wordBreak(String s, Set<String> wordDict) {
        if (s == null || wordDict == null) {
            return false;
        }
        int len = s.length();
        boolean[] dp = new boolean[len + 1];
        dp[0] = true;

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

三刷:

这道题目其实没有说清楚的是，wordDict中的元素是否可以被重复使用。测试了几次以后发现是可以的。比如S = "aa"，wordDict = ["a"]，结果为true。面试的时候一定要注意问清楚面试官的意思，一点一点clarify问题。

Java:

Recursive:

Time Complexity - O(n ^ 2)， Space Complexity - O(n ^ 2)

为什么Time Complexity是 O(n ^ 2)呢? (worst case)

对于worst case来说，递归项T(n) = T(n - 1) + 1，所以这是一个线性，再加上外层O(n)的遍历，综合起来，不考虑substring的话，就是O(n ^ 2)。空间复杂度也是 O(n ^ 2)， 就是递归栈的深度 n * 外层遍历 n。

public class Solution {
    public boolean wordBreak(String s, Set<String> wordDict) {
        if (s == null || wordDict == null) return false;
        if (s.equals("")) return true;
        for (int i = 1; i <= s.length(); i++) {
            String front = s.substring(0, i);
            if (wordDict.contains(front)) {
                if (wordBreak(s.substring(i), wordDict)) return true;
                wordDict.remove(front);
            }
        }
        return false;
    }
}

一维dp:

主要就是做一个boolean[len + 1]数组，然后根据之前保存的信息dp[j]与从j到i的新单词s.substring(j, i)来看能否从dp[j]扩展到dp[i]

Time Complexity - O(n ^ 2)， Space Complexity - O(n)

public class Solution {
    public boolean wordBreak(String s, Set<String> wordDict) {
        if (s == null || wordDict == null) return false;
        int len = s.length();
        boolean[] dp = new boolean[len + 1];
        dp[0] = true;
        for (int i = 1; i <= len; i++) {
            for (int j = 0; j < i; j++) {
                if (dp[i]) break;
                if (dp[j] && wordDict.contains(s.substring(j, i))) dp[i] = true;
            }
        }
        return dp[len];
    }
}

Reference：

http://www.cnblogs.com/springfor/p/3874731.html

http://blog.csdn.net/linhuanmars/article/details/22358863

https://leetcode.com/discuss/1523/who-can-show-me-a-dp-solution-thanks

https://leetcode.com/discuss/8479/a-solution-using-bfs

https://leetcode.com/discuss/8482/a-java-solution-with-similar-dp-idea

https://leetcode.com/discuss/11462/anyone-who-knows-time-complexity-recursion-with-dfs-here-code

https://leetcode.com/discuss/18904/java-implementation-using-dp-in-two-ways

https://leetcode.com/discuss/26956/dfs-with-path-memorizing-java-solution

https://leetcode.com/discuss/21709/dynamic-programming-simple-fast-solution-with-optimization

https://leetcode.com/discuss/41411/4-lines-in-python

https://leetcode.com/discuss/39224/a-short-dp-c%23-solution

https://leetcode.com/discuss/63212/java-solution-using-dp