516.最长回文子序列+1312.让字符串成为回文串的最少插入次数

最长回文子序列题目：

516. 最长回文子序列

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

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

示例 1：

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

示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

提示：

• 1 <= s.length <= 1000
• s 仅由小写英文字母组成

思路： 

对于一个子序列而言，如果它是回文子序列，并且长度大于 2，那么将它首尾的两个字符去除之后，它仍然是个回文子序列。反之，如果一个回文子序列两边同时加上相同字符后，它依旧也是一个回文子序列，并且长度比原来增加了2个单位，因此可以用动态规划的方法计算给定字符串的最长回文子序列。

1.用 dp[i][j] 表示字符串 s 的下标范围  [ i , j ]  内的最长回文子序列的长度。假设字符串 s 的长度为 n，则只有当 0≤  i  ≤ j <n 时，才会有 dp[i][j]>0，否则 dp[i][j]=0

2.由于任何长度为 1 的子序列都是回文子序列，因此动态规划的边界情况是，对任意 0≤i<n，都有 dp[i][i]=1

3.状态方程

第一种情况：如果s[i]=s[j]，说明可以把字符s[i]和s[j]加在两边构成一个回文字串，并且长度+2

d[i][j]=d[i+1][j-1]+2;//因为dp[i][j]是基于比它小的子序列中的,所以dp区间应该是[ i+1 ,j-1 ]

第二种情况：如果不等于，那就取区间 [ i, j ] 中 [ i , j-1 ]区间 或者 [ i+1, j ]区间的回文子序列最大值来更新dp[i][j]，因为dp[i][j]区间包含其余两个区间。

dp[i][j]=max(dp[i][j-1],dp[i+1,j]);

4.最后我们返回答案即可，因为我们是让i<j，所以i做起始位置，j做末尾，所以最后我们返回的是dp[0][n-1] ；

代码如下： 

int longestPalindromeSubseq(char * s){
    int n=strlen(s);
    int i,j;
    int dp[n][n];
    memset(dp,0,sizeof(dp));//dp初始化
    if(n==1)
    return 1;
    else{
        for (i = 0; i < n; i++)
        dp[i][i] = 1;
        for(i=n-1;i>=0;i--)
        {
            for(j=i+1;j<n;j++)
            {
                if(s[i]==s[j])
                dp[i][j]=dp[i+1][j-1]+2;
                else
                dp[i][j]=fmax(dp[i+1][j],dp[i][j-1]);
            }
        }
        return dp[0][n-1];
    }
}

让字符串成为回文串的最少插入次数题目：

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

给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。

请你返回让 s 成为回文串的 最少操作次数 。

「回文串」是正读和反读都相同的字符串。

示例 1：

输入：s = "zzazz"
输出：0
解释：字符串 "zzazz" 已经是回文串了，所以不需要做任何插入操作。

示例 2：

输入：s = "mbadm"
输出：2
解释：字符串可变为 "mbdadbm" 或者 "mdbabdm" 。

示例 3：

输入：s = "leetcode"
输出：5
解释：插入 5 个字符后字符串变为 "leetcodocteel" 。

思路（方法一）： 

 可以使用动态规划来解决这个问题。

首先定义一个二维数组dp，其中dp[i][j]表示将字符串s的第i个字符到第j个字符之间变成回文串所需的最少操作次数。

然后，可以使用两个指针i和j来遍历字符串s的所有子串，从长度为1的子串开始，逐渐增加子串的长度。对于每个子串，可以分为两种情况讨论：

1.如果s的第i个字符和第j个字符相等，那么不需要进行任何操作dp[i][j] = dp[i+1][j-1]。

2.如果s的第i个字符和第j个字符不相等，那么可以选择在第i个字符或第j个字符之间插入一个字符，使得它们相等。此时，dp[i][j] = min(dp[i+1][j], dp[i][j-1]) + 1，即取插入字符后的子串的最小操作次数加上1。

最后，当遍历完所有子串后，dp[0][n-1]即为将整个字符串s变成回文串所需的最少操作次数。

代码如下： 

int minInsertions(char * s){
    int n=strlen(s);
    int dp[n][n];
    memset(dp,0,sizeof(dp));
    if(n==1)
    return 0;
    for (int l = 2; l <= n; l++) {
    for (int i = 0; i <= n - l; i++) {
        int j = i + l - 1;
        if (s[i] == s[j]) {
            dp[i][j] = dp[i+1][j-1];
        } else {
            dp[i][j] = fmin(dp[i+1][j], dp[i][j-1]) + 1;
        }
    }
    }

    return dp[0][n-1];

}

 思路（方法二）： 

 我们看例子找规律  设字符串长度为n   ，最长回文字符串长度为len ， 需要插入的次数为p，剩余字符数量cnt

s="zzazz"      n=5      len=5  p=0        cnt=0

s="leetcode"       n=8   len=3        p=5        cnt=5

s="mbadm"        n=5        len=3        p=2        cnt=2

 通过上面例子我们发现了一个规律  n=len+p=cnt

也就是  插入次数 = 字符串长度 - 最长回文字符串长度 = 剩余字符数量

这样我们就知道了，我们算出最长回文字符串长度 就可以知道插入次数 ，除去回文字符串组成的字符，剩下的只需要我们在其字串对应位置插入相同元素即可，例如

s="mbadm"    

p‘=“m a m"

S''="mbdadbm"

 有同学可能会问，插入字符一定不会是中间的那唯一的一个吗？

答案是肯定的，因为如果插入字符是中间唯一的一个，那中间字符必定是最长回文字符串最中间的那一个字符，自然，插入字符一定会有一个唯一与它对应的字符，故此，剩余字符数量一定就是插入次数。

代码如下： 

int minInsertions(char * s){
    int n=strlen(s);
    int i,j;
    int dp[n][n];
    memset(dp,0,sizeof(dp));
    if(n==1)
    return 0;
    else{
        for (i = 0; i < n; i++)
        dp[i][i] = 1;
        for(i=n-1;i>=0;i--)
        {
            for(j=i+1;j<n;j++)
            {
                if(s[i]==s[j])
                dp[i][j]=dp[i+1][j-1]+2;
                else
                dp[i][j]=fmax(dp[i+1][j],dp[i][j-1]);
            }
        }
        return n-dp[0][n-1];
    }
}