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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-break。

代码及分析

方法一：递归

这道题目可以采用递归的方法进行求解。从字符串的首字符开始，依次向后遍历，当找到存在于字典当中的单词时，将其拆分为单词+字符串，然后递归对所得字符串求解。但是单纯这样去求解会有大量的重复极速三，造成超时的问题，故我们可以加入数组memory来保存已经计算的结果，每次计算前可以看是否存在于memory中，存在则不需要再次计算。 memory[start] 表示字符串 [i, n] 是否可拆分。
wordDict： cat, cats, and, sand, dog
s ： catsanddog 长为10
第一层：
start = 0
\quad\quad\quad i = 1 \quad c
\quad\quad\quad i = 2 \quad ca
\quad\quad\quad i = 3 \quad cat 存在 ③返回1
\quad\quad\quad 第二层 ：
\quad\quad\quad start = 3
\quad\quad\quad\quad\quad\quad i = 4 \quad s
\quad\quad\quad\quad\quad\quad i = 5 \quad sa
\quad\quad\quad\quad\quad\quad i = 6 \quad san
\quad\quad\quad\quad\quad\quad i = 7 \quad sand 存在 ②返回1
\quad\quad\quad\quad\quad\quad 第三层 ：
\quad\quad\quad\quad\quad\quad start = 7
\quad\quad\quad\quad\quad\quad\quad\quad\quad i = 8 \quad d
\quad\quad\quad\quad\quad\quad\quad\quad\quad i = 9 \quad do
\quad\quad\quad\quad\quad\quad\quad\quad\quad i = 10 \quad dog 存在 ①返回1
返回结果顺序为①->②->③，最终结果为true。

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        if(s.empty())
            return true;
        if(wordDict.empty())
            return false;
        int l = s.size();
        // 方便后续查看对应单词在字典中是否存在
        set<string> dict(wordDict.begin(),wordDict.end());
        vector<int> memory(l,-1);
        return fun(s,dict,memory,0);
        
    }
    bool fun(string s, set<string> dict, vector<int> &memory, int start)
    {
        if(start >= s.size())
            return true;
        if(memory[start] != -1)
            return memory[start];
        for(int i = start+1; i <= s.size(); i++)
        {
            if(dict.count(s.substr(start,i-start)) && fun(s,dict,memory,i))
                return memory[start] = 1;
        }
        return memory[start] = 0;
    }
    
};

复杂度：

时间复杂度： O(n^2) 。
空间复杂度： O(n) 。

方法二：动态规划法

这道题还可以用动态规划的方法去求解。
首先我们建立一个以为数组dp，其中dp[i]表示字符串[0,i)是否可以拆分，包含空字符串，故可以初始化dp[0] = true;
我们可以遍历字符串[0,i)，将其分为两部分，[0,j) 以及[j, i)，故可以得出动态转移方程为：
dp[i] = dp[j] && dict.count(s.substr(j,i-j))。

bool wordBreak(string s, vector<string>& wordDict) {
        if(s.empty())
            return true;
        if(wordDict.empty())
            return false;
        int l = s.size();
        set<string> dict(wordDict.begin(),wordDict.end());
        vector<int> dp(l+1,0);
        dp[0] = 1;
        for(int i = 1; i <= l; i++)
        {
            for(int j = 0; j < i; j++)
            {
                if(dp[j] && dict.count(s.substr(j,i-j)))
                {
                    dp[i] = 1;
                    break;
                }  
            }
        }
        return dp[l];
    }

复杂度：

时间复杂度： O(n^2) ；
空间复杂度： O(n) 。

方法三：广度优先搜索

上述我们采用了递归的方法对该问题进行了求解，实际上这就是DFS方法。
那么同样BFS应该也是可以求解的。
广度优先搜索法，也就是我们不会一次性直接遍历到最底端，而是每一步将整个字符串拆分为单词+字符串的形式，然后再继续对拆分得到的字符串进行判断（这里与DFS不同的是，DFS一旦找到一各符合要求的单词，便对后续的字符串进行求解，而BFS是先将当前可以得到的单词全部求解出来，然后分别求解各个单词对应的后续字符串）。建立一个queue，用于保存可拆分的位置。
这里我们可以建立一个memory数组，用于保存该位置是否拆分过。
举例说明：
wordDict： cat, cats, and, sand, dog
s ： catsanddog 长为10
第一次循环：
q : 0;
start = 0
\quad\quad\quad i = 1 \quad c
\quad\quad\quad i = 2 \quad ca
\quad\quad\quad i = 3 \quad cat \quad q : 3
\quad\quad\quad i = 4 \quad cats \quad q : 3, 4
i = 5， 6， 7… …
第二次循环：
q : 3, 4
start = 3
\quad\quad\quad i = 4 \quad s
\quad\quad\quad i = 5 \quad sa
\quad\quad\quad i = 6 \quad san \quad
\quad\quad\quad i = 7 \quad sand \quad q : 4, 7
i = 7, 8 … …
第三次循环：
q : 4， 7
start = 4
\quad\quad\quad i = 5 \quad a
\quad\quad\quad i = 6 \quad an
\quad\quad\quad i = 7 \quad and \quad q : 7, 7
i = 8 , 9… …
第四次循环：
q : 7， 7
start = 7
\quad\quad\quad i = 8 \quad d
\quad\quad\quad i = 9 \quad do
\quad\quad\quad i = 10 \quad dog \quad q : 7, 10
这是 i = l，故返回true。
需要注意的一点是，在这个跟例子中如果还没有到字符串结尾，那么下一次循环中，start = 7，但显然这一种情况将会和第四次循环完全相同，属于重复计算，数组memory便是为了解决这个问题而存在的，我们将每一次拆分位置保存在memory当中，在每一次循环初，我们要首先判断该位置是否已经被处理过。
其广度搜索示意图如下：

 bool wordBreak(string s, vector<string>& wordDict) {
        if(s.empty())
            return true;
        if(wordDict.empty())
            return false;
        int l = s.size();
        set<string> dict(wordDict.begin(),wordDict.end());
        queue<int> q;
        q.push(0);
        vector<int> memory(l,0);
        while(!q.empty())
        {
            int start = q.front();
            q.pop();
            if(memory[start])
                continue;
            for(int i = start+1; i <= l; i++)
            {
                if(dict.count(s.substr(start,i-start)))
                {
                    q.push(i);
                    if(i == l)
                        return true;
                }
            }
            memory[start] = 1;
        }
        return false;
    
    }

复杂度：

时间复杂度： O(n^2) ；
空间复杂度： O(n) 。