LeetCode 131. 分割回文串 139.单词拆分 140 单词拆分

131 分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: “aab”
输出:
[
[“aa”,“b”],
[“a”,“a”,“b”]
]

题解：
dfs+dp
dp[i][j] 代表s[i…j]是否是回文串，如果s[i] = s[j] 且 dp[i+1][j-1] = true,则dp[i][j] = true
然后dfs，如果前缀字符串是回文，则可以产生分支和结点；
如果前缀字符串不是回文，则不产生分支和结点，这一步是剪枝操作。

class Solution {
    public static int len;
    public boolean dp[][];
    public List<List<String>> partition(String s) {

        List<List<String>> ans = new ArrayList<List<String>>();

        len = s.length();
        if(len == 0){
            return ans;
        }
        dp = new boolean[len][len];
        for(int i = 0 ;i <len ; i++){
            for(int j = 0 ; j <= i ; j++){
                if(s.charAt(i) == s.charAt(j) && (i - j <= 2 || dp[j+1][i-1])){
                    dp[j][i] = true;
                }
            }
        }

        Deque<String> res = new ArrayDeque<String>();
        dfs(s,0,len,res,ans);
        return ans;
    }

    public void dfs(String s,int start,int len,Deque<String> res,List<List<String>> ans){
        if(start == len){
            ans.add(new ArrayList<>(res));
            return;
        }

        for(int i = start; i < len ; i++){
            if(!dp[start][i]){
                continue;
            }

            res.addLast(s.substring(start,i+1));
            dfs(s,i+1,len,res,ans);
            res.removeLast();
        }
    }
}

139、单词拆分

给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

拆分时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。

示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true 因为 “leetcode” 可以被拆分成 “leet code”。
示例 2：

输入: s = “applepenapple”, wordDict = [“apple”, “pen”]
输出: true
解释: 返回 true 因为 “applepenapple” 可以被拆分成 “apple pen apple”。
注意你可以重复使用字典中的单词。
示例 3：

输入: s = “catsandog”, wordDict = [“cats”, “dog”, “sand”, “and”, “cat”]
输出: false

题解：dp
dp[j]表示s[0…j]能不能被拆分成规定单词，如果存在j （j<i），dp[j]且s[j,i]在规定单词中，则dp[i] = true

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> words = new HashSet<>(wordDict);
        int len = s.length();
        boolean dp[] = new boolean[len+1];
        dp[0] = true;

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

140、单词拆分 II

给定一个非空字符串 s 和一个包含非空单词列表的字典
wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。
说明：
分隔时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。

示例 1：

输入:
s = “catsanddog”
wordDict = [“cat”, “cats”, “and”, “sand”, “dog”]
输出:
[
“cats and dog”,
“cat sand dog”
]

题解：dp+dfs

class Solution {

    public int len;
    public Set<String> words;
    public List<String> ans;
    public boolean[] dp;
    public List<String> wordBreak(String s, List<String> wordDict) {
        len = s.length();
        ans = new ArrayList<>();
        if(len == 0){
            return ans;
        }
        words = new HashSet<>(wordDict);

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

        Deque<String> path = new ArrayDeque<>();
        dfs(len,s,path);
        return ans;
    }

    public void dfs(int index,String s,Deque<String> path){
        if(index == 0){
            ans.add(String.join(" ",path));
            return;
        }

        for(int i = index - 1 ; i>=0 ; i--){
            String word = s.substring(i,index);
            if(words.contains(word) && dp[i]){
                path.addFirst(word);
                dfs(i,s,path);
                path.removeFirst();
            }
        }
    }
}