（LeetCode）139. 单词拆分——DFS/BFS/动态规划

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
说明：
拆分时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。
来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/word-break
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思考

DFS和BFS从来都是一个解决问题很好的方式，然而在解决此题某些案例的时候会出现超出时间限制的情况，此时需要剪枝
剪枝的部分还需要好好学习
DFS和BFS方法也需要多多练习
动态规划是我刚看到这道题所想到的解决办法，但是到写的时候才感觉无从下手，后来看了题解的动态规划，也有点似懂非懂……是我太菜了orz

DFS

public class Solution139dfs {
     
    public boolean wordBreak(String s, List<String> wordDict) {
     
        boolean[] mark = new boolean[s.length()];
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        while(!stack.isEmpty()){
     
            int start = stack.pop();
            for(String word : wordDict){
     
                int nextstart = start + word.length();
                if(nextstart < s.length() && mark[nextstart] == true){
     
                    continue;
                }
                if(s.indexOf(word,start) == start){
     
                    if(nextstart == s.length()){
     
                        return true;
                    }
                    mark[nextstart] = true;
                    stack.push(nextstart);
                }
            }
        }
        return false;
    }
}

BFS

public class Solution139bfs {
     
    public boolean wordBreak(String s, List<String> wordDict) {
     
        /*boolean[] mark = new boolean[s.length()];*/
        int[] mark = new int[s.length()];
        for(int i = 0 ;i < s.length();i++){
     
            mark[i] = 0;
        }
        int slength = s.length();
        Queue<Integer> queue = new LinkedList<>();//记录开始搜索的位置
        queue.add(0);//第一个位置是0
        while(!queue.isEmpty()){
     
            int start = queue.poll().intValue();
            for(String word : wordDict){
     
                int nextStart = start+word.length();
                if(slength < nextStart || mark[nextStart] == 1){
     
                    continue;
                }
                if(s.indexOf(word,start) == start){
     
                    if(nextStart == s.length()){
     
                        return true;
                    }
                    mark[nextStart] = 1;
                    queue.add(nextStart);
                }
            }
        }
        return false;
    }
}

动态规划

public class Solution139动态规划 {
     
    public boolean wordBreak(String s, List<String> wordDict) {
     
        boolean[] mark = new boolean[s.length()];
        for(int i = 0;i < s.length();i++){
     
            if(wordDict.contains(s.substring(0,i+1))){
     
                if(i+1 == s.length()){
     
                    return true;
                }
                mark[i] = true;
                continue;
            }
            for(int j = i-1;j >= 0;j--){
     
                if(mark[j] == true && wordDict.contains(s.substring(j+1,i+1))){
     
                    if(i+1 == s.length()){
     
                        return true;
                    }
                    mark[i] = true;
                    break;
                }
            }
        }
        return false;
    }
}