当前位置：首页 > news >正文

LeetCode 热题 100_单词拆分（86_139_中等_C++）(动态规划)

news 来源：原创 2025/5/14 13:05:38

LeetCode 热题 100_单词拆分（86_139）

- 题目描述：
- 输入输出样例：
- 题解：
- - 解题思路：
  - - 思路一（动态规划）：
  - 代码实现
  - - 代码实现（思路一（动态规划））：
    - 以思路一为例进行调试

题目描述：

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

输入输出样例：

示例 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

提示：
1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 仅由小写英文字母组成
wordDict 中的所有字符串 互不相同

题解：

解题思路：

思路一（动态规划）：

1、此题的思想就是将字符串 s 进行切分，切分后的子串与 word 中的字符串进行比较，若切分后的子串都存在word中则返回true。判断子串是否存在word可以使用哈希集合来加速查找。在判断的时候有许多重复的地方我们可以想到动态规划来记录一段子串的结果。

2、具体思路如下：
① dp[i] 表示字符串 s[0…i-1] 是否能拆分成字典中的单词（ i ∈ [ 0,s.size() ] ）。
② 递推公式为 dp[i] = dp[j] && ( s[j,i−1] ∈ word_set )。

对于每个位置 i，我们遍历 j（从 0 到 i-1），检查 dp[j] 是否为 true，即前 j 个字符已经能拆分为字典中的单词。
如果 dp[j] 为 true 且 s[j, i-1]（从位置 j 到 i-1 的子串）存在于字典中，那么 dp[i] 就可以设置为
true，表示前 i 个字符能拆分为字典中的单词。

③ dp[0] = true，因dp[i] = dp[j] && ( s[j,i−1] ∈ word_set )。dp数组中其他值为false。
④ 最终返回 dp[s.size()]。

3、复杂度分析：
① 时间复杂度：O(n²) ，n 代表 s 中字符的个数，使用双重循环。
② 空间复杂度：O(n+m) ，m 是字典 wordDict 中单词的总数，dp 数组所消耗的空间为 O(n)，哈希集合消耗的空间为 O(m)。

代码实现

代码实现（思路一（动态规划））：

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        // 将 wordDict 转换为 unordered_set 以便快速查找
        unordered_set<string> word_set(wordDict.begin(), wordDict.end());
        
        // dp[i] 的含义是：前i个字符(s[0...i-1])，是否可由wordDict 字典中的单词组成
        vector<bool> dp(s.size() + 1, false);
        // 初始化 dp[0] 为 true，因递推公式 dp[i]=dp[j]&&check(s[j~i-1])
        dp[0] = true;

        //  判断前i个字符是否可由wordDict字典中的单词组成,i从 1 到 s.size()
        for (int i = 1; i <= s.size(); i++) {
            // 对于每个位置 i，检查是否存在一个 j 使得 s[j:i] 是字典中的一个单词
            for (int j = 0; j < i; j++) {
                // 如果前j个字符可以由字典中的单词组成，并且后i-j个字符是字典中的一个单词
                if (dp[j] && word_set.count(s.substr(j, i - j))) {
                    // 如果满足条件，将 dp[i] 设置为 true
                    dp[i] = true;
                    // 一旦找到一个有效的拆分，就可以跳出内层循环
                    break;
                }
            }
        }
        
        // 返回 dp[s.size()]，表示整个字符串是否可以由字典中的单词组成
        return dp[s.size()];
    }
};

以思路一为例进行调试

#include<iostream>
#include<vector>
#include<unordered_set>
using namespace std;

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        // 将 wordDict 转换为 unordered_set 以便快速查找
        unordered_set<string> word_set(wordDict.begin(), wordDict.end());
        
        // dp[i] 的含义是：前i个字符(s[0...i-1])，是否可由wordDict 字典中的单词组成
        vector<bool> dp(s.size() + 1, false);
        // 初始化 dp[0] 为 true，因递推公式 dp[i]=dp[j]&&check(s[j~i-1])
        dp[0] = true;

        //  判断前i个字符是否可由wordDict字典中的单词组成,i从 1 到 s.size()
        for (int i = 1; i <= s.size(); i++) {
            // 对于每个位置 i，检查是否存在一个 j 使得 s[j:i] 是字典中的一个单词
            for (int j = 0; j < i; j++) {
                // 如果前j个字符可以由字典中的单词组成，并且后i-j个字符是字典中的一个单词
                if (dp[j] && word_set.count(s.substr(j, i - j))) {
                    // 如果满足条件，将 dp[i] 设置为 true
                    dp[i] = true;
                    // 一旦找到一个有效的拆分，就可以跳出内层循环
                    break;
                }
            }
        }
        
        // 返回 dp[s.size()]，表示整个字符串是否可以由字典中的单词组成
        return dp[s.size()];
    }
};

int main(int argc, char const *argv[])
{
    string s="leetcode";
    vector<string> wordDict={"leet", "code"};
    Solution s1;
    if (s1.wordBreak(s,wordDict)){
        cout<<"true"<<endl;
    }else{
        cout<<"false"<<endl;
    }
    
    return 0;
}