Leetcode Word Break II

題目地址：https://leetcode.com/problems/word-break-ii/

題目解析：看到題目的第一思路是採用遞歸暴力解法，每找到一個單詞將單詞添加到返回的結果集中，並將查找的開始位置後移直到字符串的結尾。

題目解答：

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

public class Solution {
    public List<String> wordBreak(String s, Set<String> wordDict) {
        List<String> res = new LinkedList<String>();
        if(s == null || s.length() == 0){
            return res;
        }
        
        wordBreak(s, 0, new StringBuilder(), wordDict, res);
        
        return res;
    }
    
    private void wordBreak(String s,int start,StringBuilder temp,Set<String> dict,List<String> ret){
        if(start>=s.length()){
            ret.add(temp.toString());
            return;
        }
        
        int len = temp.length();
        for(int i=start;i<s.length();i++){
            if(dict.contains(s.substring(start, i+1))){
                temp.append(temp.length() == 0 ?s.substring(start, i+1):(" "+s.substring(start, i+1)));
                wordBreak(s, i+1, temp, dict, ret);
                temp.delete(len, temp.length());
            }
        }
    }
}

這個解法的思路很簡單，可是中間有不少重複的步驟，並且這些重複的步驟有有不少字符串操做比較費時，故考慮先使用動態規劃找到能break的點，而後以能break點來遍歷找到全部break的路徑，解答以下：

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

public class Solution {
    public static List<String> wordBreak(String s, Set<String> dict) {
        if (s == null || s.length() == 0 || dict == null) {
            return null;
        }
        
        List<String> ret = new ArrayList<String>();
        
        List<String> path = new ArrayList<String>();
        
        int len = s.length();

        boolean[] D = new boolean[len + 1];
        D[len] = true;
        for(int i=len-1;i>=0;i--){
            D[i] = false;
            for(int j=i;j<len;j++){
                if(D[j+1] && dict.contains(s.substring(i,j+1))){
                    D[i] = true;
                    break;
                }
            }
        }

        dfs(s, dict, path, ret, 0, D);
        
        return ret;
    }

    public static void dfs(String s, Set<String> dict, 
            List<String> path, List<String> ret, int index,
            boolean canBreak[]) {
        int len = s.length();
        if (index == len) {
            StringBuilder sb = new StringBuilder();
            for (String str: path) {
                sb.append(str);
                sb.append(" ");
            }
            sb.deleteCharAt(sb.length() - 1);
            ret.add(sb.toString());
            return;
        }
        
        if (!canBreak[index]) {
            return;
        }

        for (int i =  index; i < len; i++) {
            String left = s.substring(index, i + 1);
            if (dict.contains(left)) {
                path.add(left);
                dfs(s, dict, path, ret, i + 1, canBreak);
                path.remove(path.size() - 1);
            }
        }

    }
}