Word Break

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".

思路：

　　DFS是最朴素的方法

　　更加高端的方法是动态规划

我的代码：

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
        if(s == null || s.length() == 0)    return true;
        int n = s.length();
        boolean [][] flag = new boolean[n][n];
        for(int size = 1; size <= n; size++)
        {
            for(int k = 0; k <= n - size; k++)
            {
                if(dict.contains(s.substring(k, k + size)))
                {
                    flag[k][k+size-1] = true;
                }
                else
                {
                    for(int j = k; j < k + size - 1; j++)
                    {
                        flag[k][k+size-1] |= (flag[k][j] & flag[j+1][k+size-1]);
                    }
                }
            }
        }
        return flag[0][n-1];
        
    }
}

他人代码：

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
        boolean [] breakable = new boolean[s.length()+1];
        breakable[0] = true;

        for(int i=1;i<=s.length();i++){
            for(int j=0;j<i;j++){
                if(breakable[j]&&dict.contains(s.substring(j,i))){
                    breakable[i] = true;
                    break;
                }
            }
        }
        return breakable[s.length()];
    }
}

学习之处：

• 对于string的切分问题，DFS肯定是可以解决的，时间复杂度过高，所以我们要想到的是否可以用动态规划解决
• 常用的一个模板

        for(int size = 1; size <= n; size++)
        {
            for(int k = 0; k <= n - size; k++)
            {
                for(int i = k; i < k + size; i++)
                {
                }
            }
        }

• 这个动态规划问题，好好想想就想出来了，我是用的二维数组进行存储的，动态规划方程如下图所示，别人用一维数组也解决了，更加简练一些，最外层的循环只是string 的size 从1 --> n这也是常用的外在添加的循环。
• 动态规划的思想是大问题由所有的小问题情况的集合组成的。大问题== 所有小问题