动态规划回文子串篇-代码随想录算法训练营第四十二天 |647. 回文子串，1745.回文串分割IV，132.回文串分割Ⅱ，5.最长回文子串，516.最长回文子序列，

热爱编程的OP

于 2024-08-29 18:58:51 发布

阅读量735

点赞数 16

分类专栏： leetcode 文章标签：算法动态规划 c++ leetcode 学习

本文链接：https://blog.csdn.net/m0_67804957/article/details/141682803

版权

leetcode 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

647. 回文子串

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划，字符串性质决定了DP数组的定义 | LeetCode：647.回文子串

题目描述：

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"

解题思路：

1. 状态表示：
为了能表示出来所有的子串，我们可以创建一个 n * n 的二维 dp 表，只用到「上三角部分」
即可。其中， dp[i][j] 表示： s 字符串 [i, j] 的子串，是否是回文串。

2. 状态转移方程：
对于回文串，我们一般分析一个「区间两头」的元素：
1）当 s[i] != s[j] 的时候：不可能是回文串， dp[i][j] = 0 ；
2）当 s[i] == s[j] 的时候：根据长度分三种情况讨论：

长度为 1 ，也就是 i == j ：此时一定是回文串， dp[i][j] = true ；
长度为 2 ，也就是 i + 1 == j ：此时也一定是回文串， dp[i][j] = true ；
长度大于 2 ，此时要去看看 [i + 1, j - 1] 区间的子串是否回文： dp[i][j] = dp[i + 1][j - 1] 。

综上，状态转移方程分情况谈论即可。

3. 初始化：
因为我们的状态转移方程分析的很细致，因此无需初始化。

4. 填表顺序：
根据「状态转移方程」，我们需要「从下往上」填写每一行，每一行的顺序无所谓。

5. 返回值：
根据「状态表示和题目要求」，我们需要返回 dp 表中 true 的个数。

代码：

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        vector<vector<int>> dp(n,vector<int>(n));
        int ret = 0;
        for(int i = n-1; i >= 0; i--)
        {
            for(int j = i; j < n; j++)
            {
                if(s[i] != s[j]) dp[i][j] = false;
                else
                {
                    if(i == j || i + 1 == j) dp[i][j] = true;
                    else dp[i][j] = dp[i+1][j-1];
                }
                if(dp[i][j]) ret++;
            }
        }
        return ret;
    }
};

1745.回文串分割IV

题目链接：. - 力扣（LeetCode）

题目描述：

给你一个字符串 s ，如果可以将它分割成三个非空回文子字符串，那么返回 true ，否则返回 false 。当一个字符串正着读和反着读是一模一样的，就称其为 回文字符串 。

示例 1：

输入：s = "abcbdd"
输出：true
解释："abcbdd" = "a" + "bcb" + "dd"，三个子字符串都是回文的。

解题思路：

我们可以把它拆成「两个小问题」：

动态规划求解字符串中的一段非空子串是否是回文串；
枚举三个子串除字符串端点外的起止点，查询这三段非空子串是否是回文串。

那么这道困难题就免秒变为简单题啦，变成了一道枚举题。

代码：

class Solution {
public:
    bool checkPartitioning(string s) {
        int n = s.size();
        vector<vector<int>> dp(n,vector<int>(n));
        for(int i = n-1; i >= 0; i--)
            for(int j = i; j < n; j++)
                if(s[i] == s[j])
                    dp[i][j] = (i == j || i + 1 == j) ? true : dp[i+1][j-1];

        for(int i = 1; i < n; i++)
        {
            for(int j = i+1; j < n; j++)
            {
                if(dp[0][i-1] && dp[i][j-1] && dp[j][n-1]) return true;
            }
        }
        return false;
    }
};

132.回文串分割Ⅱ

题目链接：. - 力扣（LeetCode）

题目描述：

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是

回文串。返回符合要求的 最少分割次数 。

示例 1：

输入：s = "aab"
输出：1
解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

解题思路：

1. 状态表示：
dp[i] 表示： s 中 [0, i] 区间上的字符串，最少分割的次数。

2. 状态转移方程：
状态转移方程一般都是根据「最后一个位置」的信息来分析：设 0 <= j <= i ，那么我们可以
根据 j ~ i 位置上的子串是否是回文串分成下面两类：
1）当 [j ,i] 位置上的子串能够构成一个回文串，那么 dp[i] 就等于 [0, j - 1] 区间上最少回文串的个数 + 1，即dp[i] = dp[j - 1] + 1 ；
2）当 [j ,i] 位置上的子串不能构成一个回文串，此时 j 位置就不用考虑。由于我们要的是最小值，因此应该循环遍历一遍 j 的取值，拿到里面的最小值即可。
优化：我们在状态转移方程里面分析到，要能够快速判读字符串里面的子串是否回文。因此，我们可以先处理一个 dp 表，里面保存所有子串是否回文的信息。

3. 初始化：
为了防止求 min 操作时， 0 干扰结果。我们先把表里面的值初始化为「无穷大」。

4. 填表顺序：
毫无疑问是「从左往右」。

5. 返回值：
根据「状态表示」，应该返回 dp[n - 1] 。

代码：

class Solution {
public:
    int minCut(string s) {
        int n = s.size();
        vector<vector<int>> dp(n,vector<int>(n));
        vector<int> result(n,INT_MAX);
        result[0] = 0;

        for(int i = n - 1; i >= 0; i--)
            for(int j = i; j < n; j++)
                if(s[i] == s[j])
                    dp[i][j] = (i == j || i + 1 == j) ? true : dp[i+1][j-1];

        for(int i = 1; i < n; i++)
            if(dp[0][i]) result[i] = 0;
            else
            {
                for(int j = i; j >= 1; j--)
                    if(dp[j][i]) result[i] = min(result[i],result[j-1] + 1);
            }
        return result[n - 1]; 
    }
};

5.最长回文子串

题目链接：. - 力扣（LeetCode）

题目描述：

给你一个字符串 s，找到 s 中最长的

回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

解题思路：

a. 先用 dp 表统计出「所有子串是否回文」的信息
b. 然后根据 dp 表示 true 的位置，得到回文串的「起始位置」和「长度」。
那么就可以在表中找出最长回文串。

代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        vector<vector<bool>> dp(n,vector<bool>(n));
        int left = 0, cnt = 0;
        for(int i = n - 1; i >= 0; i--)
        {
            for(int j = i; j < n; j++)
            {
                if(s[i] == s[j]) 
                {
                    dp[i][j] = (i == j || i + 1 == j) ? true : dp[i+1][j-1];
                    if(dp[i][j] && j - i + 1 > cnt) left = i, cnt = j - i + 1;
                }
            }
        }
        return s.substr(left,cnt);
    }
};

516.最长回文子序列

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划再显神通，LeetCode：516.最长回文子序列

题目描述：

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。

解题思路：

1. 状态表示：
dp[i][j] 表示：s 字符串 [i, j] 区间内的所有的子序列中，最长的回文子序列的长度。

2. 状态转移方程：
关于「回文子序列」和「回文子串」的分析方式，一般都是比较固定的，都是选择这段区域的「左右端点」的字符情况来分析。因为如果一个序列是回文串的话，「去掉首尾两个元素之后依旧是回文串」，「首尾加上两个相同的元素之后也依旧是回文串」。因为，根据「首尾元素」的不同，可以分为下面两种情况：
1）当首尾两个元素「相同」的时候，也就是 s[i] == s[j] ：那么 [i, j] 区间上的最长回文子序列，应该是 [i + 1, j - 1] 区间内的那个最长回文子序列首尾填上s[i] 和 s[j] ，此时 dp[i][j] = dp[i + 1][j - 1] + 2；
2）当首尾两个元素不「相同」的时候，也就是 s[i] != s[j] ：此时这两个元素就不能同
时添加在一个回文串的左右，那么我们就应该让 s[i] 单独加在一个序列的左边，或者
让 s[j] 单独放在一个序列的右边，看看这两种情况下的最大值：

单独加入 s[i] 后的区间在 [i, j - 1] ，此时最长的回文序列的长度就是 dp[i][j - 1] ；
单独加入 s[j] 后的区间在 [i + 1, j] ，此时最长的回文序列的长度就是 dp[i+ 1][j] ；

取两者的最大值，于是 dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])，综上所述，状态转移方程为：

当 s[i] == s[j] 时： dp[i][j] = dp[i + 1][j - 1] + 2
当 s[i] != s[j] 时： dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])

3. 初始化：
我们的初始化一般就是为了处理在状态转移的过程中，遇到的一些边界情况，因为我们需要根据状态转移方程来分析哪些位置需要初始化。
根据状态转移方程 dp[i][j] = dp[i + 1][j - 1] + 2 ，我们状态表示的时候，选取的是一段区间，因此需要要求左端点的值要小于等于右端点的值，因此会有两种边界情况：

当 i == j 的时候， i + 1 就会大于 j - 1 ，此时区间内只有一个字符。这个比较好分析， dp[i][j] 表示一个字符的最长回文序列，一个字符能够自己组成回文串，因此此时 dp[i][j]=1 ；
当 i + 1 == j 的时候， i + 1 也会大于 j - 1 ，此时区间内有两个字符。这样也好分析，当这两个字符相同的时候， dp[i][j] = 2 ；不相同的时候， d[i][j] =0 。

对于第一种边界情况，我们在填表的时候，就可以同步处理。
对于第二种边界情况， dp[i + 1][j - 1] 的值为 0 ，不会影响最终的结果，因此可以不用
考虑。

4. 填表顺序：
根据「状态转移」，我们发现，在 dp 表所表示的矩阵中， dp[i + 1] 表示下一行的位置，
dp[j - 1] 表示前一列的位置。因此我们的填表顺序应该是「从下往上填写每一行」，「每一
行从左往右」。这个与我们一般的填写顺序不太一致。

5. 返回值：
根据「状态表示」，我们需要返回 [0, n -1] 区域上的最长回文序列的长度，因此需要返回
dp[0][n - 1] 。

代码：

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        vector<vector<int>> dp(n,vector<int>(n));
        int ret = 0;
        for(int i = n - 1; i >= 0; i--)
        {
            for(int j = i; j < n; j++)
            {
                if(s[i] == s[j])
                {
                    if(i == j) dp[i][j] = 1;
                    else if(i + 1 == j) dp[i][j] = 2;
                    else dp[i][j] = dp[i+1][j-1] + 2;
                }
                else
                    dp[i][j] = max(dp[i+1][j],dp[i][j-1]);
                ret = max(ret,dp[i][j]);
            }
        }
        return ret;
    }
};

热爱编程的OP

关注

16
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
动态规划回文子串篇-代码随想录算法训练营第四十二天 |647. 回文子串，1745.回文串分割IV，132.回文串分割Ⅱ，5.最长回文子串，516.最长回文子序列，

647. 回文子串，1745.回文串分割IV，132.回文串分割Ⅱ，5.最长回文子串，516.最长回文子序列，
复制链接

扫一扫

专栏目录