[C++]LeetCode: 112 Word Break(DP)

最新推荐文章于 2025-06-03 15:43:33 发布

Cindy_niu

最新推荐文章于 2025-06-03 15:43:33 发布

阅读量1.8k

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode 文章标签： Dynamic Programming leetcode

本文链接：https://blog.csdn.net/cinderella_niu/article/details/42915093

LeetCode 专栏收录该内容

132 篇文章

订阅专栏

本文探讨了字符串分割算法，包括递归、动态规划及BFS三种方法。递归方法简单直观但效率较低；动态规划方法通过自底向上构建状态，显著提高了效率；BFS则提供了一种全新的遍历视角。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

Answer 1: 递归，自顶向下（TLE）

思路：从s的第一个字母开始匹配，逐个递增子串长度，如果前缀可以匹配，再匹配后面的子串。

但是这种方法，时间复杂度为O(N^2)，超过LeetCode时间限制。

Error Code:

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        if (s.size() == 0) return false;
        return wordBreak_helper(s, dict, 0);
    }
    
private:
    bool wordBreak_helper(string s, unordered_set<string>& dict, int pos)
    {
        //pos表示截取字符串的起始位置
        if (pos == s.size())
            return true;
        
        for (int i = 1; i <= s.size()-pos; i++)
        {
            //截取子串，并判断是否在字典内
            string substr = s.substr(pos, i);
            if (dict.find(substr) != dict.end())
            {
                wordBreak_helper(s, dict, pos+i);
            }
        }
        
        return false;
    }
};

Answer 2: DP, 自底向上的动态规划

思路：我们从字符串末尾开始匹配。dp[i]表示子串S[i...len-1]是否可以根据字典进行拆分。dp[len]表示空串，dp[0]即s[0..len-1]为我们要求的答案。

每一次循环迭代时，我们进行一种新的拆分方式，用索引j 来拆分子串s[i..len-1]，如果我们可以找到一个子串s[i..j]是在字典内，并且s[j+1..len-1]（即dp[j+1]）是可拆分的，则我们可以知dp[i]是可拆分的。而且s[i..j]总之在判断完s[j+1..len-1]后计算，即总之会先得到dp[j+1]的结果，我们可以通过DP算法存储之前的拆分结果。节省了判断时间。

具体可以看下图加以理解：

Attention:

1. 初始化动态规划数组时，我们要构建len+1个，因为从字符串末尾最后一个字母计算时，要知道dp[len], dp[len]表示空串，为true.

<span style="font-size:14px;">//dp[i]表示S[i..len-1]是否可break
        vector<bool> dp(len + 1, false);
        dp[len] = true;</span>

2. 我们在进行单词是否可拆分时，从后往前拆分，可以省去很多判断。考虑DP问题时，每次可以从自顶向下和自底向上，两个角度考虑，寻找最佳解决方案。

复杂度：O(N^2)

AC Code:

class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        int len = s.size();
        if(s.size() == 0) return false;
        
        //dp[i]表示S[i..len-1]是否可break
        vector<bool> dp(len + 1, false);
        dp[len] = true;
        
        for(int i = len - 1; i >= 0; i--)
        {
            for(int j = i; j < len; j++)
            {
                string substr = s.substr(i, j - i + 1);
                if(dict.find(substr) != dict.end() && dp[j+1] == true)
                {
                    dp[i] = true;
                    break;
                }
            }
        }
        return dp[0];
    }
};

Answer 3: BFS

有种新的解法，利用BFS的方法来遍历字符串。可以看下leetcode这篇文章：A-solution-using-bfs