备战秋招60天算法挑战，Day30

题目链接： https://leetcode.cn/problems/word-break/

视频题解： https://www.bilibili.com/video/BV1ZSvheYEsk/

LeetCode 139. 单词拆分

题目描述

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

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

举个例子：

输入:  s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

视频题解

单词拆分

思路来源

思路来源

知识回顾

动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递归结构，二是对应的子问题能否记忆化。动态规划可以通过带备忘录的自上而下的递归和自下而上的迭代来分别实现。由于递归需要用到栈来实现，一些语言对递归的深度是有限制的，所以自下而上的迭代是动态规划的最佳实现方式。

思路解析

对于s = "leetcode", wordDict = ["hello", "leet", "code"]的决策树如下:

观察决策树，此问题存在递归结构且子问题可以记忆化。所以本题可以用动态规划来解，动态规划的两个核心点是推导状态转移公式和边界处理。

首先定义dp[i]为字符串s的[0, i)区间是否可以利用字典中出现的单词拼接。dp[i] == true代表可以。

推导的核心思想就是：

• 在遍历s的过程中如果满足wordDict中的单词word和字符串s的区间[i, i + len(word))组成的子串相同且dp[i] == true，就更新dp[i+len(word)] = dp[i]。

所以状态转移公式 就是dp[i+len(word)] = dp[i]。
定义边界条件 dp[0] = true。

对于上面的例子dp[8] = dp[4] = dp[0] = true。

C++代码

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {

        int s_len = s.length();
        //定义dp
        vector<bool> dp(s_len + 1, false);
        //边界条件
        dp[0] = true;
        for (int i = 0; i < s_len; ++i) {
            for (auto& word:wordDict) {
                int word_len = word.length();
                if (dp[i] && (i + word_len <= s_len) && s.substr(i, word_len) == word) {
                    //状态转移公式
                    dp[i + word_len] = dp[i];
                }
            }
        }
        return dp[s_len];
    }
};

java代码

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int s_len = s.length();
        // 定义 dp
        boolean[] dp = new boolean[s_len + 1];
        // 边界条件
        dp[0] = true;

        for (int i = 0; i < s_len; ++i) {
            for (String word : wordDict) {
                int word_len = word.length();
                if (dp[i] && (i + word_len <= s_len) && s.substring(i, i + word_len).equals(word)) {
                    // 状态转移公式
                    dp[i + word_len] = dp[i];
                }
            }
        }
        return dp[s_len];
    }
}

python代码

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        s_len = len(s)
        # 定义 dp
        dp = [False] * (s_len + 1)
        # 边界条件
        dp[0] = True

        for i in range(s_len):
            for word in wordDict:
                word_len = len(word)
                if dp[i] and (i + word_len <= s_len) and s[i:i + word_len] == word:
                    # 状态转移公式
                    dp[i + word_len] = dp[i]

        return dp[s_len]

复杂度分析

时间复杂度： O(mn)，其中m为s的长度，n为wordDict的长度。

空间复杂度： O(m)，其中m为s的长度。