判断字符串能否根据给定的词典划分 Word Break

为什么80%的码农都做不了架构师？>>>   

问题：

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

解决：

①  dfs，超时，时间复杂度O（n^2）。

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
         Set<String> set = new HashSet<>(wordDict);
        return dfs(s,set,0);
    }
    public boolean dfs(String s,Set<String> set,int i){
        if (i == s.length()) {
            return true;
        }
        for (String str : set ) {
            int len = str.length();
            int j = i + len;
            if(j > s.length()) continue;
            if (s.substring(i,j).equals(str)) {
                if (dfs(s,set,j)) {
                    return true;
                }
            }
        }
        return false;
    }
}

② 动态规划。时间复杂度O（string length * dict size）

初始状态dp[0] = true;

dp[i] = true表示 0 到 i - 1可以得字符串可以由dictionary中的字符串组成。

class Solution { //14ms
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> set = new HashSet<>(wordDict);
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for (int i = 0;i < s.length() ;i ++ ) {
            if(dp[i] == false) continue;
            for (String str : set) {
                int len = str.length();
                int j = i + len;
                if(j > s.length()) continue;
                if (dp[j]) {
                    continue;
                }
                if (s.substring(i,j).equals(str)) {
                    dp[j] = true;
                }
            }
        }
        return dp[s.length()];
    }
}

③ 在方法②中，如果wordDict太大的话，耗时会增加很多。使用另一种方法，时间复杂度为O（n^2）。n表示s的长度。

class Solution {//17ms
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> set = new HashSet<>(wordDict);
        int[] dp = new int[s.length() + 1];
        Arrays.fill(dp,-1);
        dp[0] = 0;
        for (int i = 0;i < s.length() ;i ++ ) {
            if (dp[i] != -1) {
                for (int j = i + 1;j <= s.length() ;j ++ ) {
                    String sub = s.substring(i,j);
                    if (set.contains(sub)) {
                        dp[j] = i;
                    }
                }
            }
        }
        return dp[s.length()] != -1;
    }
}

④ 在discuss中看到的效率比较高的，从最长的词组开始比较

class Solution { //5ms
    public boolean wordBreak(String s, List<String> wordDict) {
       if(s == null || s.length() == 0){
            return true;
        }
        if(wordDict == null || wordDict.size() == 0){
            return false;
        }
        Set<String> set = new HashSet<>(wordDict);
        int len = getMaxLength(wordDict);
        boolean[] dp = new boolean[s.length() + 1];
        dp[0] = true;
        for(int i = 1; i < dp.length;i ++) {
            for(int j = Math.max(i - len, 0); j < i; j ++) {
                if(dp[j] && set.contains(s.substring(j, i))){
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[dp.length - 1];
    }
    private int getMaxLength(List<String> wordDict) {
        int max = 0;
        for(String s : wordDict) {
            max = Math.max(s.length(), max);
        }
        return max;
    }
}

转载于:https://my.oschina.net/liyurong/blog/1545458