【回溯 + 动态规划】LeetCode - 131. 分割回文串

最新推荐文章于 2025-06-04 22:19:50 发布

weixin_43842888

最新推荐文章于 2025-06-04 22:19:50 发布

阅读量243

点赞数

分类专栏：回溯动态规划文章标签： leetcode

本文链接：https://blog.youkuaiyun.com/weixin_43842888/article/details/113900845

版权

动态规划同时被 2 个专栏收录

8 篇文章

订阅专栏

回溯

4 篇文章

订阅专栏

本文探讨了两种解题方法在LeetCode中的应用：回溯和动态规划。解法1使用回溯法，通过剪枝有效地找出所有回文子串，而解法2利用动态规划预先计算子串的回文性质，以O(1)时间复杂度获取结果。尽管动态规划理论上更优，但在实际问题中，回溯法由于其高效的剪枝能力，运行时间可能更短。

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

题目描述

题目链接
在这里插入图片描述

解法1：回溯

题目要求列出所有符合的情况，不满足回文的直接剪枝，很适合回溯。

class Solution {
private:
    vector<vector<string> > ans;
    vector<string> elem;//ans中的成员
    int len;
    //检查是否是回文字符串
    bool check(const string& str, int left, int right)
    {
        while(left < right)
        {
            if(str[left] != str[right])
             return false;
            ++left;
            --right;
        }
        return true;
    }
    //DFS递归回溯
    void DFS(const string& s, int start)
    {
        if(start == len)
        {
            ans.push_back(elem);
            return;
        }
        for(int i = start; i < len; i++)
        {
            if(! check(s, start, i))//[start,i]注意是闭区间
             continue;
            elem.push_back(s.substr(start, i - start + 1));
            DFS(s, i + 1);
            elem.pop_back();//回溯
        }
    }
public:
    vector<vector<string>> partition(string s) {
        len = s.size();
        if(len == 0) return ans;
        DFS(s, 0);
        return ans;
    }
};

解法2：动态规划

也可以利用动态规划把结果先算出来，这样就可以以 O(1) 的时间复杂度直接得到一个子串是否是回文，也就是用空间换取时间

class Solution {
private:
    vector<vector<string> > ans;
    vector<string> elem;//ans中的成员
    int len;
    
    //DFS递归回溯
    void DFS(const string& s, int start, vector<vector<bool> >dp)
    {
        if(start == len)
        {
            ans.push_back(elem);
            return;
        }
        for(int i = start; i < len; i++)
        {
            if(! dp[start][i])//[start,i]注意是闭区间
             continue;
            elem.push_back(s.substr(start, i - start + 1));
            DFS(s, i + 1, dp);
            elem.pop_back();//回溯
        }
    }
    
public:
    vector<vector<string>> partition(string s) {
        len = s.size();
        if(len == 0) return ans;
        //利用动态规划把结果先算出来，这样就可以 O(1) 的时间复杂度直接得到一个子串是否是回文。
        vector<vector<bool> > dp(len, vector<bool>(len, false));
        // 状态：dp[i][j] 表示 s[i][j] 是否是回文
        // 状态转移方程：在 s[i] == s[j] 的时候，dp[i][j] 参考 dp[i + 1][j - 1]
        //memset(dp, false, sizeof dp);
        for (int right = 0; right < len; right++)
        {
        // 注意：left <= right 取等号表示 1 个字符的时候也需要判断
            for (int left = 0; left <= right; left++)
            {
                if(s[left] == s[right] && (right - left < 3 || dp[left + 1][right - 1]))
                 dp[left][right] = true;
            }
        }
        DFS(s, 0, dp);
        return ans;
    }
};