Leetcode——单词拆分

1. 单词拆分

（1）DFS

最容易想到的就是回溯了，找到每个子串，逐一判断是否存在于字典中

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

    //startIndex表示的是从字符串s的哪个位置开始
    public boolean dfs(String s, List<String> wordDict, int startIndex) {

        //字符串中的所有字符都遍历完了，也就是到叶子节点了，说明字符串s可以拆分成
        //在字典中出现的单词，直接返回true
        if (startIndex == s.length())
            return true;
        
        //开始拆分字符串s，
        for (int i = startIndex + 1; i <= s.length(); i++) {
            //如果截取的子串不在字典中，继续截取更大的子串
            if (!wordDict.contains(s.substring(startIndex, i)))
                continue;

            //如果截取的子串在字典中，继续剩下的拆分，如果剩下的可以拆分成
            //在字典中出现的单词，直接返回true，如果不能则继续
            //截取更大的子串判断
            if (dfs(s, wordDict, i))
                return true;
        }
        
        return false;
    }


}

（1）DFS优化

我们会发现超时了，这是因为如果字符串s比较长的话，这里会包含大量的重复计算

所以这里可以考虑用备忘录算法优化一下

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

    public boolean dfs(String s, List<String> wordDict, Set<Integer> indexSet, int startIndex) {
        //字符串都拆分完了，返回true
        if (startIndex == s.length())
            return true;

        for (int i = startIndex + 1; i <= s.length(); i++) {
            //如果已经判断过了，就直接跳过，防止重复判断
            if (indexSet.contains(i))
                continue;

            //截取子串，判断是否是在字典中
            if (wordDict.contains(s.substring(startIndex, i))) {
                if (dfs(s, wordDict, indexSet, i))
                    return true;
                //标记为已判断过
                indexSet.add(i);
            }
        }
        return false;
    }
}

（2）BFS

思路与DFS基本一致，只需要使用一个队列记录每一层需要记录的值即可。BFS中在截取的时候，如果截取的子串存在于字典中，我们就要记录截取的位置，到下一层的时候就从这个位置的下一个继续截取

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        //这里为了提高效率，把list转化为set，因为set的查找效率要比list高
        Set<String> setDict = new HashSet<>(wordDict);

        //记录当前层开始遍历字符串s的位置
        Queue<Integer> queue = new LinkedList<>();
        queue.add(0);
        int length = s.length();
        while (!queue.isEmpty()) {
            int index = queue.poll();

            //如果字符串到遍历完了，自己返回true
            if (index == length)
                return true;

            for (int i = index + 1; i <= length; i++) {
                if (setDict.contains(s.substring(index, i))) {
                    queue.add(i);
                }
            }
        }
        return false;
    }

}

（2）BFS（优化）

跟DFS一样，直接BFS也包含了大量重复计算

class Solution {
     public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> setDict = new HashSet<>(wordDict);

        //记录当前层开始遍历字符串s的位置
        Queue<Integer> queue = new LinkedList<>();
        queue.add(0);
        int length = s.length();

        //记录访问过的位置，减少重复判断
        boolean[] visited = new boolean[length];

        while (!queue.isEmpty()) {
            int index = queue.poll();
            //如果字符串都遍历完了，直接返回true
            if (index == length)
                return true;

            //如果被访问过，则跳过
            if (visited[index])
                continue;
    
            //标记为访问过
            visited[index] = true;

            for (int i = index + 1; i <= length; i++) {
                if (setDict.contains(s.substring(index, i))) {
                    queue.add(i);
                }
            }
        }
        return false;
    }

}

（3）动规

• 定义dp[i]表示字符串的前i个字符经过拆分是否都存在于字典wordDict中。
• 如果要求dp[i]，我们需要往前截取k个字符，判断子串[i-k+1，i]是否存在于字典wordDict中，并且前面[0，i-k]子串拆分的子串也是否都存在于wordDict中，如下图所示
  
  前面[0，i-k]子串拆分的子串是否都存在于wordDict中只需要判断dp[i-k]即可，而子串[i-k+1，i]是否存在于字典wordDict中需要查找，所以动态规划的递推公式很容易列出来

dp[i] = dp[i-k] && dict.contains(s.substring(i - k, i));

这个k我们需要一个个枚举：

class Solution {
    public boolean wordBreak(String s, List<String> dict) {
        boolean[] dp = new boolean[s.length() + 1];
        for (int i = 1; i <= s.length(); i++) {
            //枚举k的值

            for (int k = 0; k <= i; k++) {
                //如果往前截取全部字符串，我们直接判断子串[0,i-1]
                //是否存在于字典wordDict中即可
                if (k == i) {
                    if (dict.contains(s.substring(0, i))) {
                        dp[i] = true;
                        continue;
                    }
                }
                //递推公式
                dp[i] = dp[i - k] && dict.contains(s.substring(i - k, i));
                
                //如果dp[i]为true，说明前i个字符串结果拆解可以让他的所有子串
                //都存在于字典wordDict中，直接终止内层循环，不用再计算dp[i]了。
                if (dp[i]) {
                    break;
                }
            }
        }
        return dp[s.length()];
    }
}