leetcode *139. 单词拆分

【题目】*139. 单词拆分

*139. 单词拆分
*面试题 17.13. 恢复空格

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：
拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。

示例 1：

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

示例 2：

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

示例 3：

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

【解题思路1】动态规划

假如需要判断"onetwothreefour"这一个字符串能不能满足条件，自然的想法就是：
如果"onetwothree"这一段可以拆分，"four"也可以，那"onetwothreefour"就可以
或者如果"onetwothre"这一段可以拆分，"efour"也可以，那"onetwothreefour"就可以

dp["onetwothreefour"] = dp["onetwothree"] && 判断一下"four"
dp["onetwothreefour"] = dp["onetwothre"] && 判断一下"efour"

定义dp[i]的含义： 字符串 s 前 i 个字符组成的字符串 s[0…i−1] 是否能被空格拆分成若干个字典中出现的单词。
初始化/边界条件：dp[0]=true 表示空串且合法。
状态转移方程：
从前往后计算考虑转移方程，需要枚举 s[0…i-1] 中的分割点 j ，看 s[0…j-1] 组成的字符串s1（默认 j = 0 时 s1为空串）和 s[j…i−1] 组成的字符串 s2是否都合法，如果两个字符串均合法，那么按照定义 s1和 s2拼接成的字符串也同样合法。由于计算到 dp[i] 时我们已经计算出了 dp[0…i−1] 的值，因此字符串 s1是否合法可以直接由 dp[j] 得知，剩下的只需要看 s2是否合法即可，因此可以得出如下转移方程：
dp[i] = dp[j] && check(s[j…i−1])，其中 check(s[j…i−1]) 表示子串 s[j…i−1] 是否出现在字典中。

对于检查一个字符串是否出现在给定的字符串列表里一般可以考虑哈希表来快速判断

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

可以做一些简单的剪枝，枚举分割点的时候倒着枚举（从i-1的位置往0枚举），如果分割点 j 到 i 的长度已经大于字典列表里最长的单词的长度，那么就结束枚举。

public class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> wordDictSet = new HashSet(wordDict);
        int max = 0; //最长的单词长度
        for(String word: wordDictSet){
            max = Math.max(word.length(), max);
        }
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for (int i = 1; i <= s.length(); i++) {
            for (int j = i - 1; j >= 0; j--) {
                if(i - j > max){ //子串s2的长度已经大于最长的单词长度
                    break;
                }
                if (dp[j] && wordDictSet.contains(s.substring(j, i))) {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}

【解题思路2】DFS（未研究）

BFS

public class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        return wordBreakHelper(s, wordDict, new ArrayList<>(), 0);
    }

    //start表示的是从字符串s的哪个位置开始
    public boolean wordBreakHelper(String s, List<String> wordDict, List<Integer> excludeList, int start) {
        if (start == s.length())
            return true;
        for (int end = start + 1; end <= s.length(); end++) {
            if (excludeList.contains(end))
                continue;
            if (wordDict.contains(s.substring(start, end))) {
                if (wordBreakHelper(s, wordDict, excludeList, end))
                    return true;
                excludeList.add(end);
            }
        }
        return false;
    }
}