【动态规划】C++解决回文串类算法题（最长/回文子串、分割回文串、回文子序列、最少插入次数）

1. 前言

关于 动态规划的理解 与例题，点击👇

【动态规划】C++解决斐波那契模型题目（三步问题、爬楼梯、解码方法…）

有了上面的经验，我们来解下面 回文串类问题

2. 算法题

2.1_回文子串

题意分析

• 题目要求 找到字符串s中的回文子串的个数
• 我们可以使用中心扩展算法（枚举每一位作为回文子串的中心部分，再用双指针向左右两侧遍历）
• 这里使用动态规划(复杂度：n^2, n^2)

思路

1. 设置状态表示
   • dp[i][j]：字符串s->(i, j) 范围内的子串是否回文
2. 写状态转移方程

3. 初始化
   • 不用初始化，直接填表即可（状态转移方程考虑了回文串长度为1、2的情况）
4. 填表的顺序
   • 由于用到了i+1与j-1的下标，则从下向上填表
5. 返回值
   • 遍历dp表，返回true的个数

代码

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        vector<vector<bool>> dp(n, vector<bool>(n, false)); // dp[i][j]: s中{i, j} 范围的子串是否为回文串
        // if(s[i] != s[j]) dp[i][j] = false; // 默认为false

        // 从下向上 + 从左向右 填表
        int ret = 0; // 记录回文串个数
        for(int i = n - 1; i >= 0; --i)
        {
            for(int j = i; j < n; ++j)
            {
                // if(i == j || i+1 == j) dp[i][j] = true; // 直接用下面的代码 
                if(s[i] == s[j]) // 长度为1、2的分类讨论
                    dp[i][j] = i + 1 < j ? dp[i+1][j-1] : true;
            
                // 统计回文串个数
                if(dp[i][j]) ++ret;
            }
        }

        return ret;
    }
};

---

2.2_最长回文子串

题意分析

• 本题与上一题类似，上一题要求回文子串的个数，本题要求最长的长度，只需要对结果的返回作更改即可

思路

1. 设置状态表示
   • dp[i][j]：字符串s->(i, j) 范围内的子串是否回文
2. 写状态转移方程

3. 初始化
   • 不用初始化，直接填表即可（状态转移方程考虑了回文串长度为1、2的情况）
4. 填表的顺序
   • 由于用到了i+1与j-1的下标，则从下向上填表
5. 返回值
   • 通过循环更新最大值ret，在dp值为true的情况下，统计j-i+1与ret的值

代码

class Solution {
public:
    string longestPalindrome(string s) {
        // 动态规划：
        int n = s.size();
        vector<vector<bool>> dp(n, vector<bool>(n, false));

        string ret = "";
        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])
                ret = ret.size() > j - i + 1 ? ret : s.substr(i, j - i + 1);
            }   
        }

        return ret;
    }
};

---

2.3_分割回文串IV

题意分析

• 题目要求判断能否将一个字符串分割成三个回文子串（非空）
• 我们可以利用前面的题的思路，利用dp表可以判断一个(i, j)范围内的子串是否为回文串

思路

本题的dp表依然和前两道题一样，不再重复，直接介绍思路：

1. 预处理dp表（上两题的步骤）
2. 两层循环遍历字符串（两个指针将字符串可以分为三部分）：找是否存在三个分割后的回文串
   • 两层每次通过if(dp[0][i-1] && dp[i][j] && dp[j+1][n-1]) ，统计分隔的三部分是否满足条件

代码

class Solution {
public:
    bool checkPartitioning(string s) {
        int n = s.size();

        // 预处理dp数组，用于判断{i, j}范围子串是否为回文串
        vector<vector<bool>> dp(n, vector<bool>(n, false));
        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;

        // 两层循环 遍历字符串找是否存在分割回文串
        for(int i = 1; i < n - 1; ++i)
            for(int j = i; j < n - 1; ++j)
            {
                if(dp[0][i-1] && dp[i][j] && dp[j+1][n-1])
                    return true;          
            }

        return false;
    }
};

---

2.4_分割回文串II

题意分析

• 题目要求找将字符串分隔后都是回文串的最少分割次数

与上一题 《分割回文子串Ⅳ》 一样，首先预处理一个dp数组，用于判断 i~j 范围的子串是否为回文串

思路

1. 设置状态表示
   • dp[i]表示：s[0, i] 范围内的最长子串（即起点到终点的子串） 的最少分割次数
2. 写状态转移方程

3. 初始化
   • 将dp表值初始化为无限大（因为后面比较用的是min）
4. 填表的顺序
   • 从左向右填表
5. 返回值
   • dp[n-1]

代码

class Solution {
public:
    int minCut(string s) {
        int n = s.size();

        // 预处理dp数组，用于判断{i,j}范围的最长子串是否为回文串
        vector<vector<bool>> isPal(n, vector<bool>(n, false)); 
        for(int i = n-1; i >= 0; --i)
            for(int j = i; j < n; ++j)
                if(s[i] == s[j])
                    isPal[i][j] = i+1 < j ? isPal[i+1][j-1] : true;

        vector<int> dp(n, INT_MAX); //dp[i]: s[0, i] 范围最长的子串 的最少分割次数
        for(int i = 0; i < n; ++i)
        {
            if(isPal[0][i]) dp[i] = 0; // 本身就是回文，不用分割
            else {
                for(int j = 1; j <= i; ++j)
                    if(isPal[j][i]) 
                        dp[i] = min(dp[i], dp[j - 1] + 1);
            }
        }

        return dp[n-1];
    }
};

---

2.5_最长回文子序列

题意分析

• 本题类似2.2《最长回文子串》，区别在于本题要求的是最长的回文子序列
• 同样我们进行dp表的创建：

思路

1. 设置状态表示
   • 根据一般情况，我们会定义dp[i]：以i位置为结尾的所有子序列中，最长的子序列长度 ，但该状态表示无法正确推出状态转移方程
   • 这里需要定义：dp[i][j]：[i, j]范围内的所有子序列中最长的子序列长度
2. 写状态转移方程

3. 初始化
   • 不用初始化
4. 填表的顺序
   • 从上向下填行，每行从左往右
5. 返回值
   • dp[0][n-1]（整个字符串的最长回文子序列）

代码

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int n = s.size();
        // 初始化dp数组
        vector<vector<int>> dp(n, vector<int>(n, 0));
        
        // 填表
        for(int i = n-1; i >= 0; --i)
        {
            dp[i][i] = 1; // i==j 即回文子序列长度为1时
            for(int j = i+1; j < n; ++j)
            {
                if(s[i] == s[j]) dp[i][j] = dp[i+1][j-1] + 2; // 当i+1=j时，dp[i][j]为2
                else dp[i][j] = max(dp[i][j-1], dp[i+1][j]);
            }
        }
        return dp[0][n-1];
    }
};

---

2.6_让字符串成为回文串的最少插入次数

题意分析

• 题目要求将字符串变成回文串的最小操作次数，跟随2.5的思路，我们创建dp数组。

思路

1. 设置状态表示

   • dp[i][j]：i~j 范围下的子串变为回文串的最小插入次数

2. 写状态转移方程

   

3. 初始化

   • 无需初始化

4. 填表的顺序

   • 从下向上填行，每行从左往右

5. 返回值

   • dp[0][n-1]

代码

class Solution {
public:
    int minInsertions(string s) {
        int n = s.size();
        // 初始化dp数组: dp[i][j]表示 范围在{i, j}内的最少插入次数
        vector<vector<int>> dp(n, vector<int>(n, 0));

        // 填表
        for(int i = n-1; i >= 0; --i) // 从下到上
            for(int j = i + 1; j < n; ++j) // 从左到右
            {
                if(s[i] == s[j]) dp[i][j] = dp[i+1][j-1]; // i==j 与 i+i==j 时dp[i][j]即为0
                else dp[i][j] = min(dp[i][j-1], dp[i+1][j]) + 1;
            }

        return dp[0][n-1];
    }
};