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

思路： 法1： Using DFS , if this sub string is contained in the dictionary, move to next step. At last, if the start equals to the string length, return true; But in leetcode, this method time limit exceed.

易错点： substring  的 开始和结尾的地方。

法2： 用一位数组的方法， 如果当前点isSeg[i] = true ， 说明这是一个合法分割。 进行双重遍历， 首先 起点必须是true 才可以， 然后看j  to  i  这个单词是否正确， 如果正确 直接设置 i  为true  ， 否则 找 j 和 i  中间是否有个 合法分割 k 。一维数组就可搞定。 思想和 二维的一样。

public class Solution {
		public boolean wordBreak(String s, Set<String> dict) {
			int len = s.length();
			if (len < 1)
				return false;
			boolean[] isSeg = new boolean[len + 1];
			isSeg[0] = true;
			for (int i = 1; i <= len; i++) {
				for (int j = 0; j < i; j++) {
					if (isSeg[j]) {
						String cur = s.substring(j, i);
						if (dict.contains(cur)) {
							isSeg[i] = true;
						} else {
							for (int k = j + 1; k < i; k++) {
								if (isSeg[k] && dict.contains(s.substring(k, i))) {
									isSeg[i] = true;
									break;
								}
							}
						}
					}
				}
			}
			return isSeg[len];
		}
	}

法3： 用dynamic programming . 用一个 Boolean 的 二维数组seg[i][j]  存储结果， i 是 substing 的开始，  j  是长度。 如果 seg[i][j]  为 true, 说明 从i 开始， j长度的 字符串在dictionary 内。 然后两重循环来找， 如果j 长度的没有， 就从1 到 j 长度中找， 如果 i  到 i + k  和 i + k  到 i + j 都是word ，就i  到 i +　ｊ就是ｔｒｕｅ；

易错点：　先进行　ｊ　长度的外循环　在进行ｉ　从０　　到　ｉ　＋　ｊ　＜＝　ｌｅｎ　的内循环。

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
        boolean[] ret = new boolean[1];
        dfs(0, s, ret, dict);
        return ret[0];
    }
    
    private void dfs(int start, String s, boolean[] isFind, Set<String> dict){
        if(start == s.length()){
            isFind[0] = true;
            return;
        }
        if(isFind[0])
            return;
        
        for(int i = start + 1; i <= s.length(); i++){
            String cur = s.substring(start, i);
            if(dict.contains(cur)){
                dfs(i, s, isFind, dict);
            }
        }
    }
}

public class Solution {
    public boolean wordBreak(String s, Set<String> dict) {
		int len = s.length();
		boolean[][] seg = new boolean[len][len + 1];
		for (int j = 1; j <= len; j++) {// j is the len of substring
			for (int i = 0; i + j <= len; i++) {// i is the start of substring
				String cur = s.substring(i, i + j);
				if (dict.contains(cur)) {
					seg[i][j] = true;
				} else {
					for (int k = 1; k < j; k++) {
						if (seg[i][k] && seg[i + k][j - k]) {//----
							seg[i][j] = true;
							break;
						}
					}
				}
			}
		}
		return seg[0][len];
	}
    
}

public class Solution {
    public boolean wordBreak(String s, Set<String> wordDict) {
        int len = s.length();
        if(len < 1)
            return false;
        boolean[] dp = new boolean[len + 1];
        for(int i = 1; i <= len; i++){
            if(wordDict.contains(s.substring(0, i))){
                dp[i] = true;
            }else{
                for(int j = 1; j < i; j++){
                    if(dp[j] && wordDict.contains(s.substring(j, i))){
                        dp[i] = true;
                        break;
                    }
                }
            }
        }
        return dp[len];
    }
}