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);
            }
        }

    }
}

 

转载于:https://www.cnblogs.com/xiongyuesen/p/4440497.html