1312. 让字符串成为回文串的最少插入次数

思路

这个问题可以通过动态规划来解决。我们可以定义一个二维数组 dp，其中 dp[i][j] 表示将子串 s[i...j] 转换为回文字符串所需的最小插入次数。然后，我们可以利用动态规划的思想来填充这个数组。

解题方法

我们从右下角开始，逐步向左上角填充动态规划数组 dp。对于任意子串 s[i...j]：

如果 s[i] == s[j]，则不需要进行插入操作，因为 s[i] 和 s[j] 已经匹配，所以 dp[i][j] = dp[i + 1][j - 1]。
如果 s[i] != s[j]，则需要进行插入操作。此时，我们可以取左边或上边的最小插入次数，并加上1，即 dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]) + 1。
最终，dp[0][n - 1] 即为整个字符串 s 转换为回文字符串所需的最小插入次数。

复杂度

时间复杂度:

我们需要填充一个二维数组 dp，其中有 n2 个元素。在填充每个元素时，我们需要进行常数次操作。因此，时间复杂度为 O(n2)
空间复杂度:

我们定义了一个二维数组 dp。因此，空间复杂度为 O(n2) 
 

class Solution {
public:
    int minInsertions(string s) {
        int n = s.size();
        vector<std::vector<int>> dp(n, std::vector<int>(n));

        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]; 
                } else {
                    dp[i][j] = min(dp[i + 1][j], dp[i][j - 1])+1; 
                }
            }
        }
        return dp[0][n - 1];
    }
};


//dp[i][j]  ?  dp[i][i] = 0


//  动态规划   leetcode    //codedoc
// d[i+1][j-1]  

类似 516. 最长回文子序列 

class Solution {
public:
    int longestPalindromeSubseq(std::string s) {
        int n = s.size();
        // 创建二维动态规划表，dp[i][j] 表示 s 中从 i 到 j 的最长回文子序列的长度
        std::vector<std::vector<int>> dp(n, std::vector<int>(n));

        for (int i = n - 1; i >= 0; i--) {
            dp[i][i] = 1; // 初始化，单个字符是回文子序列，长度为1

            for (int j = i + 1; j < n; j++) {
                // 分两种情况填写 dp 表
                if (s[i] == s[j]) {
                    dp[i][j] = dp[i + 1][j - 1] + 2; // 左右端点相同，长度加2
                } else {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); // 左右端点不同，取左或上的最大值
                }
            }
        }

        // 返回结果，整个字符串的最长回文子序列长度位于 dp[0][n-1]
        return dp[0][n - 1];
    }
};