【LeetCode】动态规划—139. 单词拆分（附完整Python/C++代码）

前言

字符串分割问题是算法中非常常见的一类问题，尤其是当给定一个字典，要求判断字符串能否通过字典中的单词进行拼接时。该问题在自然语言处理、文本分析等领域有着广泛应用。

本题要求通过词典中的单词将字符串 s 完全分割，并判断是否存在这样的分割方式。为了解决该问题，动态规划是一种高效且合理的解决思路。本文将通过动态规划方法来解析这一问题，结合 Python 和 C++ 代码详细讲解每一步的实现，帮助你深入理解此类问题的解决方法。

题目描述

基本思路

1. 问题定义

给定一个字符事 $s$ 和一个包含若干词汇的字典 wordDict，判断字符事 $s$ 是否可以被拆分成若干个在 wordDict 中出现的单司。换句话说，需要确定是否可以通过字典中的词汇组合出字符事 $s$ 。

2. 理解问题和递推关系

• 这个问题可以通过动态规划来解决。核心在于判断字符事的每个子事是否可以被词典中的词汇覆盖。
• 定义一个布尔数组 $dp$ ，其中 $dp[i]$ 表示字符 $s[0:i]$ 是否可以通过词典中的词汇拆分。
• 递推关系：
• 对于每个位置 i，需要检查之前的某个位置 $j(0<=j<i)$ 是否满足 $dp[j]==$ True，并且 $s[j:1]$ 在 wordDict 中。如果都满足, 则 $dp[i]=$ True 。
• 递推公式: $dp[i]=dp[j]$ and $s[j:i]$ in wordDict, 其中 $\theta <=$ < i 。

3. 解决方法

3.1 动态规划方法

1. 初始化一个布尔数组 $dp$ ，长度为 $len(s)+1$ ，表示从空字符串开始到 $s$ 的每个子事是否可以拆分成字典中的单词。初始化 $dp[0]=$ True 表示空字符事可以被拆分。
2. 遍历字符串的每个位置 i，对于每个位置 i，再遍历之前的每个位置j，判断 $dp[j]$ 是否为 True，并且 $s[j:i]$ 是否在 wordDict 中。
3. 如果 $dp[\mathrm{len}(s)=$True ，则说明字符事可以被拆分；否则，不可以。

3.2 优化方法

• 提前对 wordDict 中的词汇进行哈帝处理，以便快速查找子事是否在词典中。
• 可以用切片长度来限制内部的洧环遍历，减少不必要的子事判断。

4. 进一步优化

• 空间优化: 动态规划数组 $dp$ 的空间复杂度为 $O(n)$ ，已经是最优解，但可以通过跳过无效位置的遍历来优化时间复杂度。
• 剪枝: 如果wordDict 中词汇的最大长度是 max_len, 那么每次检查子事时只需要考虑长度为 max_len 的子串，这可以减少不必要的判断。

5. 小总结

• 这个问题可以通过动态规划来解决，动态规划的状态转移方程依赖于之前位置的可拆分性和当前子事是否在字典中。空间复杂度为 $O(n)$ ，时间复杂度为 $O(n\wedge 2)$ ，可以通过优化来减少一些不必要的计算。
• 动态规划在处理字符串的分割问题时非常适用，通过将复杂问题拆解为子问题，可以有效地进行求解。

以上就是单词拆分问题的基本思路。

代码实现

Python3代码实现

class Solution:
    def wordBreak(self, s: str, wordDict: list[str]) -> bool:
        # 将词典转换为集合，方便快速查找
        word_set = set(wordDict)
        n = len(s)
        # 初始化dp数组，dp[i]表示s[0:i]是否可以被拆分
        dp = [False] * (n + 1)
        dp[0] = True  # 空字符串可以被拆分
        
        # 遍历字符串s的每个位置
        for i in range(1, n + 1):
            # 检查从前面的某个位置j到当前位置i的子串是否在wordDict中
            for j in range(i):
                if dp[j] and s[j:i] in word_set:
                    dp[i] = True
                    break  # 找到满足条件的子串后，跳出循环
        
        # 返回s[0:n]是否可以被拆分
        return dp[n]

Python 代码解释

• 集合加速查找：使用集合 word_set 来加速子串的查找操作。
• 动态规划数组：dp 数组的长度为 n+1，其中 dp[i] 表示前 i 个字符能否由字典中的单词拼成。
• 递推公式：通过遍历子串 s[j:i] 来判断是否存在满足条件的子串，并更新 dp 数组。
• 结果：最终返回 dp[n]，表示整个字符串是否可以被拆分。

C++代码实现

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        // 将wordDict转换为unordered_set，方便快速查找
        unordered_set<string> word_set(wordDict.begin(), wordDict.end());
        int n = s.length();
        // 初始化dp数组，dp[i]表示s[0:i]是否可以被拆分
        vector<bool> dp(n + 1, false);
        dp[0] = true;  // 空字符串可以被拆分
        
        // 遍历字符串s的每个位置
        for (int i = 1; i <= n; ++i) {
            // 检查从前面的某个位置j到当前位置i的子串是否在wordDict中
            for (int j = 0; j < i; ++j) {
                if (dp[j] && word_set.find(s.substr(j, i - j)) != word_set.end()) {
                    dp[i] = true;
                    break;  // 找到满足条件的子串后，跳出循环
                }
            }
        }
        
        // 返回s[0:n]是否可以被拆分
        return dp[n];
    }
};

C++ 代码解释

• unordered_set加速查找：利用 unordered_set 来高效查找子串是否存在于字典中。
• 动态规划数组：创建 dp 数组，dp[i] 表示前 i 个字符是否可以由词典中的单词拼成。
• 递推公式：遍历子串 s[j:i]，如果找到满足条件的子串，则更新 dp[i]。
• 返回结果：dp[n] 表示整个字符串是否可以通过字典中的单词拼成。

---

总结:

• 动态规划 是解决字符串分割问题的核心思想。通过定义一个 dp 数组，逐步计算每个子串是否可以被词典中的单词覆盖，从而判断整个字符串能否被完全拆分。
• 时间复杂度：该方法的时间复杂度为 $O(n\wedge 2)$ ，其中 n 为字符串的长度。内层循环检查每个子串是否存在于词典中，外层遍历字符串的每个位置。
• 空间复杂度：动态规划数组 dp 的空间复杂度为 $O(n)$，加上词典查找的空间复杂度，整体空间复杂度为 $O(m+n)$ ，其中 m 为字典的大小。
• 在实际应用中，利用哈希表（set 或 unordered_set）可以提高子串查找的效率，进一步提升算法的性能。