[LeetCode] 139. word split

Topic links: https://leetcode-cn.com/problems/word-break/

Subject description:

Given a string s non-empty and non-empty dictionary wordDict comprising a word list, it is determined whether the space s can be split into one or more words appear in the dictionary.

Description:

• Word in the dictionary can be reused when the split.
• You can assume that there is no repetition of the word in the dictionary.

Example:

Example 1:

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。

Example 2:

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
     注意你可以重复使用字典中的单词。

Example 3:

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出: false

Ideas:

Dynamic Programming

A thought: top-down,

Thinking two: bottom-up,

dp[i]It indicates sto iwhether the position can be made wordDictconsisting of

So if there dp[i - j]is trueand s[j:i]the wordDictinside dp[i] = true;

They are both easy to understand! Look at the code on the line

---

Related Questions: 140. Split words II

Code:

A thought:

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        import functools
        wordDict = set(wordDict)
        if not wordDict:return not s
        # 找最长单词的长度
        max_len = max(map(len, wordDict)) 
        @functools.lru_cache(None)
        def helper(s):
            # 递归终止条件
            if not s:
                return True
            for i in range(len(s)):
                # 判断是否满足条件
                if i < max_len and s[:i+1] in wordDict and helper(s[i+1:]):
                    return True
            return False
        return helper(s)

java

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int max_len = 0;
        for (String word : wordDict) max_len = Math.max(max_len, word.length());
        return helper(s, max_len, wordDict, new HashMap<String, Boolean>());

    }

    private boolean helper(String s, int max_len, List<String> wordDict, HashMap<String, Boolean> cache) {
        if (cache.containsKey(s)) return cache.get(s);
        if (s == null || s.length() == 0) return true;
        for (int i = 0; i < s.length(); i++) {
            if (i < max_len && wordDict.contains(s.substring(0, i + 1)) && helper(s.substring(i + 1), max_len, wordDict, cache)) {
                cache.put(s, true);
                return true;
            }
        }
        cache.put(s, false);
        return false;
    }
}

Thinking two:

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        n = len(s)
        if not wordDict: return not s
        dp = [False] * (n + 1)
        dp[0] = True
        for i in range(1, n + 1):
            for j in range(i - 1, -1, -1):
                if dp[j] and s[j:i] in wordDict:
                    dp[i] = True
                    break
        return dp[-1]

java

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