Leetcode - Word Break

[题目]

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

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

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

[分析] 摘自http://blog.csdn.net/linhuanmars/article/details/22358863

动态规划三步走法：首先，考虑解决问题过程中需要存储什么历史信息并采用何种数据结构合理；然后最关键的一步，推导递推关系式，即如何利用历史信息将问题推进解决，更具体地说如何获得当前状态；最后思考初始化条件。 

[tips] 用StringBuilder只需要调用一次substring(), 因此version3实现耗时要远小于version1 & 2

public class Solution {
    // version 3
    // 历史信息：dp[i] 表示s.substring(0, i)能否用dict中的词汇表示
    // 递推式：dp[i] |= dp[j] & dict.contains(s.substring(j,i)), 其中0 <= j < i
    public boolean wordBreak(String s, Set<String> dict) {
        if (s == null || s.length() == 0)
            return false;
        int n = s.length();
        boolean[] dp = new boolean[n + 1];
        dp[0] = true;
        for (int i = 1; i <= n; i++) {
            StringBuilder sub = new StringBuilder(s.substring(0, i));
            for (int j = 0; j < i; j++) {
                if (dp[j] && dict.contains(sub.toString())) {
                    dp[i] = true;
                    break;
                }
                sub.deleteCharAt(0);
            }
        }
        return dp[n];
    }
}

 

public class Solution {
    // version 1： 二维数组保存历史信息
    public boolean wordBreak(String s, Set<String> dict) {
        //思路1：遍历dict，寻找能成为当前子串前缀的单词，递归判断剩余子串。大数据超时！
        //思路2：动态规划。回溯时有重复计算。f[i,j] |= f[i, k-1] && f[k, j] (i < k <= j), 
        if(s == null)
            return false;
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        for(int i = n - 1; i >= 0; i--){
            dp[i][i] = dict.contains(s.substring(i, i + 1));
            for(int j = i + 1; j < n; j++){
                dp[i][j] = dict.contains(s.substring(i, j + 1));
                if(dp[i][j])
                    continue;
                for(int k = i; k < n; k++){
                    dp[i][j] |= dp[i][k] && dp[k + 1][j];
                    if(dp[i][j])
                        break;
                }
            }
        }
        return dp[0][n-1];
    }
    
    // 一维数组
    public boolean wordBreak(String s, Set<String> dict) {
        //思路2：动态规划。回溯时有重复计算。dp[i] = dict.contains(s(i, k)) && dp[k] 
        if(s == null)
            return false;
        int n = s.length();
        boolean[] dp = new boolean[n + 1];
        dp[n] = true;
        for(int i = n - 1; i >= 0; i--){
            for(int k = i + 1; k <= n; k++){
                dp[i]= dict.contains(s.substring(i,k)) && dp[k];
                if(dp[i])
                    break;
            }
        }
        return dp[0];
    }
    
}