动态规划——回文串问题

最新推荐文章于 2025-02-26 21:23:50 发布

dbln

最新推荐文章于 2025-02-26 21:23:50 发布

阅读量1.4k

点赞数 33

分类专栏：动态规划文章标签：动态规划算法

本文链接：https://blog.youkuaiyun.com/zdlynj/article/details/142392389

版权

动态规划专栏收录该内容

9 篇文章

订阅专栏

一、回文子串

回文子串

第一步：确定状态表示

dp[i][j]：表示在字符串s中，区间 [i，j]的子串是否是回文串。

第二步：推出状态转移方程

填表顺序：在求dp[i][j] 的值时，我们需要用到 dp[i+1][j-1]位置的值，所以需要从下往上，从左往右依次填写dp表。最后的返回值就是dp表中true的个数。

解题代码：

class Solution 
{
public:
    int countSubstrings(string s) 
    {
        int n = s.size();
        vector<vector<bool>> dp(n, vector<bool>(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] = i+1 < j ? dp[i+1][j-1] : true;
                }
                if(dp[i][j] == true)
                    ret++;
            }
        }
        return ret;
    }
};

二、最长回文子串

最长回文子串

第一步：确定状态表示

dp[i][j]：表示在字符串s中，区间 [i，j]的子串是否是回文串。

第二步：推出状态转移方程

dp表中存的结果只是该区间的子串是否是回文串，而题目要求我们返回最长的回文子串。所以，我们需要使用两个变量，len来表示最长回文子串的长度，begin来表示最长回文子串的起始位置。

填表顺序：在求dp[i][j] 的值时，我们需要用到 dp[i+1][j-1]位置的值，所以需要从下往上，从左往右依次填写dp表。

解题代码：

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

                if(dp[i][j] && j-i+1 > len)
                        len = j-i+1, begin = i;
            }
        }
        return s.substr(begin, len);
    }
};

三、回文串分割IV

回文串分割IV

思考：我们可以把所有可能分割出来的三个子串枚举一下，然后判断这三个是否是回文串就可以了。

我们可以这样枚举：固定一个 i 位置，一个 j 位置，i j 表示的是分割出来的第二个字符串的起始位置和结束位置，那整个字符串，就被分成 [0, i -1]，[i, j]， [j+1, n-1] 三个部分。

然后我们可以通过dp表去迅速判断子串是否是回文串。

我们通过dp表，保存所有子串是否是回文的信息，接下来在枚举所有第二个字符串的起始位置和结束位置，仅需在dp表里面查一下三个部分是否是回文就行了。

第一步：确定状态表示

dp[i][j]：表示在字符串s中，区间 [i，j]的子串是否是回文串。

第二步：推出状态转移方程

解题代码：

class Solution
{
public:
    bool checkPartitioning(string s) 
    {
        int m = s.size();
        // s中区间在[i, j]的字符串是否是回文串
        vector<vector<bool>> dp(m, vector<bool>(m)); 
        for(int i = m-1; i >= 0; i--)
        {
            for(int j = i; j < m; j++)
            {
                if(s[i] == s[j])
                    dp[i][j] = i+1 < j ? dp[i+1][j-1] : true;
            }
        }

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

        return false;
    }
};

四、回文串分割II

回文串分割II

第一步：确定状态表示

dp[i]：表示字符串 s 的 [0，i] 区间上的最长子串，分割成若干个回文串，最少的分割次数。

第二步：推出状态转移方程

如果[0，i]区间的子串本身就是回文了，根本不需要切割了。

如果[0，i]区间的子串不是回文，这个时候就想dp[i]能不能用之前的状态来表示。如果 [0，i] 区间中有一个位置 j 切割出来一个 [j，i] 的子串，如果[j，i] 是一个回文串，接下来在 [0，j-1] 看看切割少次，然后再加上切出来的[j，i] 这一次就可以了。

然后我们可以通过第一题的那种dp表去迅速判断子串是否是回文串。

第三步：初始化dp表。

将dp表内所有的值都初始化为无穷大。

dp[i] 表示 s [0，i] 区间上的最长的子串，最少分割次数，这道题要求整个区间的最少分割次数，所以返回 dp[n-1]。

解题代码：

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

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

五、最长回文子序列

最长回文子序列

第一步：确定状态表示

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

第二步：推出状态转移方程

填写顺序为从下往上填写每一行，每一行从左往右填写。

dp[i][j] 表示字符串 s 的 [i，j] 区间内的所有子序列中，最长的回文子序列的长度。最后的结果，我们要的是整个区间的最长的回文子序列的长度，因此返回 dp[0][m-1]。

解题代码：

class Solution 
{
public:
    int longestPalindromeSubseq(string s) 
    {
        int m = s.size();
        vector<vector<int>> dp(m, vector<int>(m));
        for(int i = m-1; i >= 0; i--)
        {
            for(int j = i; j < m; 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][j-1], dp[i+1][j]);
            }
        }
        return dp[0][m-1];
    }
};

六、让字符串成为回文串的最小插入次数

让字符串成为回文串的最小插入次数

第一步：确定状态表示

dp[i][j]：表示字符串s里面 [i，j] 区间内的子串，使它成为回文串的最小插入次数。

第二步：推出状态转移方程

填写顺序为从下往上每一行，每一行从左往右。

dp[i][j]表示字符串s里面 [i，j] 区间内的子串，使它成为回文串的最小插入次数，而我们要的是整个区间的最小插入次数，因此返回 dp[0][m-1]

解题代码：

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