leetcode-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

解题

方法一：回溯

参考链接

第一种回溯超时了，第二种剪枝后，就不超时了。

class Solution {
     
public:
    bool backtracing(string s,unordered_set<string>& wordSet,int startIndex){
     
        if(startIndex>=s.size()) return true;
        for(int i=startIndex;i<s.size();i++){
     
            string word=s.substr(startIndex,i-startIndex+1);
            if(wordSet.find(word)!=wordSet.end()&&backtracing(s,wordSet,i+1)){
     
                return true;
            }
        }
        return false;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
     
        unordered_set<string> wordSet(wordDict.begin(),wordDict.end());
        return backtracing(s,wordSet,0);
    }
};

剪枝后

class Solution {
     
public:
    bool backtracing(string s,unordered_set<string>& wordSet,vector<int>& memory,int startIndex){
     
        if(startIndex>=s.size()) return true;

        if (memory[startIndex] == 0) return false;//以startIndex开始的子串是不可以被拆分的，直接return
        for(int i=startIndex;i<s.size();i++){
     
            string word=s.substr(startIndex,i-startIndex+1);
            if(wordSet.find(word)!=wordSet.end()&&backtracing(s,wordSet,memory,i+1)){
     
                return true;
            }
        }
        memory[startIndex] = 0; // 记录以startIndex开始的子串是不可以被拆分的
        return false;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
     
        unordered_set<string> wordSet(wordDict.begin(),wordDict.end());
        vector<int> memory(s.size(), -1); // -1 表示初始化状态
        return backtracing(s,wordSet,memory,0);
    }
};

方法二：动态规划

参考链接
可以把字符串大小，看成背包容量
把每个字典中出现的单词看作物品

本题最终要求的是是否都出现过，所以对出现单词集合里的元素是组合还是排列，并不在意
那么本题使用求排列的方式，还是求组合的方式都可以。

初始dp[0]=True,出0外dp[i]=False
如果dp[i]=true,就代表容量为i的字串串s[0:i+1]可以装满，单词，反之则不可以

也就是说,要判断5到8的时候，5到8是一个单词，那么必定要求dp[4]=true可以拆分为一个或者以上的单词，这样才能使得dp[8]可以拆分。

class Solution {
     
public:
    bool wordBreak(string s, vector<string>& wordDict) {
     
        unordered_set<string> wordSet(wordDict.begin(),wordDict.end());
        vector<bool> dp(s.size()+1,false);
        dp[0]=true;
        for(int i=1;i<=s.size();i++){
     //遍历背包
            for(int j=0;j<i;j++){
     //遍历物品
                string word=s.substr(j,i-j);
                if(wordSet.find(word)!=wordSet.end()&&dp[j]){
     
                    dp[i]=true;
                }
            }
            
        }
        return dp[s.size()];

    }
};