单词拆分

作者：xiao_ben_zhu
链接：https://leetcode-cn.com/problems/word-break/solution/shou-hui-tu-jie-san-chong-fang-fa-dfs-bfs-dong-tai/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

给定一个非空字符串 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

力扣原题

问题分析：
DFS 思路
"leetcode"能否break，可以拆分为："l"是否是单词表的单词、剩余子串能否break，"le"是否是单词表的单词、剩余子串能否break……
用 DFS 回溯，考察所有的拆分可能，指针从左往右扫描 s 串：
1. 如果指针的左侧部分是单词表中的单词，则对右侧的剩余子串，递归考察。
2. 如果指针的左侧部分不是单词表的单词，不用看了，回溯，考察别的分支。

    public boolean wordBreak(String s, List<String> wordDict) {
        return dfs(s, 0, wordDict);
    }

    public boolean dfs(String s, int start, List<String> wordDict){
        if(start == s.length()){
            return true;
        }
        
        for(int i=start;i<s.length();i++){
            if(wordDict.indexOf(s.substring(start, i+1))!=-1 && dfs(s, i+1, wordDict)){
                return true;
            }
        }
        return false;
    }

该方法会大量重复计算：

加入记忆化
我们用一个数组，存计算的结果，数组索引为指针位置，值为计算的结果。下次遇到相同的子问题，直接返回数组中的缓存值。

    public boolean wordBreak(String s, List<String> wordDict) {
        Boolean[] memory = new Boolean[s.length()];
        return dfs(s, 0, wordDict, memory);
    }

    public boolean dfs(String s, int start, List<String> wordDict, Boolean[] memory){
        if(start == s.length()){
            return true;
        }
        if(memory[start]!=null)return memory[start];

        for(int i=start;i<s.length();i++){
            if(wordDict.indexOf(s.substring(start, i+1))!=-1 && dfs(s, i+1, wordDict, memory)){
                memory[start] = true;
                return true;
            }
        }
        memory[start] = false;
        return false;
    }

动态规划

• s 串能否分解为单词表的单词，即：前 s.length 个字符的 s 串能否分解为单词表单词。
• 将大问题分解为规模小一点的子问题，规模就是这个长度：
• 前 i 个字符的子串能否分解成单词表单词 + 剩余子串是否为单个单词。

状态转移方程

• [0, i][0,i] 区间子串 的 dp[i+1]dp[i+1] 是否为真，取决于两部分：
• 它的前缀子串 [0, j-1][0,j−1] 的 dp[j]dp[j] ，是否为真
  剩余子串 [j,i][j,i] ，是否是一个单词表单词
  base case
  dp[0] = true。长度为 0 的子串是由单词表的单词组成的。是很诡异。
  但，这只是为了让边界情况也能满足状态转移方程，即上图：当黄色部分为空字符串时，dp[i+1]dp[i+1] 全然取决于 [0,i][0,i] 子串是否为一个单词表单词。
  所以我们让 dp[0] = true

public boolean wordBreak(String s, List<String>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++){
                String sub = s.substring(j, i);
                if(dp[j]&&wordDict.contains(sub)){
                   dp[i] = true;
                   break;
                }
            }
        }
        return dp[s.length()];
    }