动态规划课堂6-----回文串问题

引言：

例题1：回文子串

例题2：回文串分割IV

例题3：分割回文串II

例题4：最长回文子序列

例题5：让字符串成为回文串的最小插入次数

引言：

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

动态规划的回文串问题一般是把子串是否是回文串的信息保持在dp表里面，所以更多的时候回文串的dp表只是起到一个辅助的作用，有一些题要利用回文串dp表再做一次动态规划，其实很多困难题某一些步骤都是可以动态规划来化简的。😎😎😎

例题1：回文子串

链接：回文子串

题目简介：

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

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

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

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

解法（动态规划）：

当然这题的最优解不是动态规划而是中心拓展算法，但是我们这里主要叙述动态规划。

这一题其实就是一个把回文子串信息保存在dp表里面的模板题😎

对于本题我们可以先预处理⼀下，将所有子串是否回⽂的信息统计在dp 表⾥⾯，然后直接在表里面统计true 的个数即可。

1. 状态表示：

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

这个二维的dp表其实只需用到上三角的地方，因为j是大于等于i的。

2.状态转移方程：

对于回文串，我们⼀般分析⼀个区间两头的元素：例如下图利用最外层和内层的递推关系完成动态规划。

（1）当s[i] != s[j] 的时候：不可能是回文串， dp[i][j] = 0 ；

（2）当s[i] == s[j] 的时候：根据长度分三种情况讨论：

1.⻓度为1 ，也就是i == j ，此时⼀定是回文串， dp[i][j] = true。

2.⻓度为2 ，也就是i + 1 == j ：此时也⼀定是回⽂串， dp[i][j] = true 。

3.⻓度⼤于2 ，此时要去看看[i + 1, j - 1] 区间的子串是否回文： dp[i][j] = dp[i + 1][j - 1] 。

3.初始化：

无需初始化，因为我们填表的范围如下图，会越界的节点在对角线，但是我们上面的状态转移方程已经把i == j的情况特判了，所以不会越界。

4.填表顺序：

从下往上

5.返回值：

返回dp 表中true 的个数。

代码如下：

dp[i][j] = i + 1 < j ? dp[i + 1][j - 1] : true;解释如下：因为i == j 和i + 1 == j 的情况下dp[i][j]都为true，长度大于2对应i + 1 < j 的情况。

class Solution {
    public int countSubstrings(String ss) {
        //1.创建 dp 表
        //2.初始化
        //3.填表
        //4.返回值
        int n = ss.length();
        char[] s = ss.toCharArray();
        boolean[][] dp = new boolean[n][n];
        int count = 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){
                    count++;
                }
            }
        }
        return count;

    }
}

时间复杂度：O（n^2）

空间复杂度：O（n^2）

下面我给出一题大家练练手，解法过程和例题1差不多就是最后创建完回文dp表最后的返回值不一样。最长回文子串

例题2：回文串分割IV

链接：回文串分割IV

题目简介：

给你一个字符串 s ，如果可以将它分割成三个非空回文子字符串，那么返回 true ，否则返回 false 。

当一个字符串正着读和反着读是一模一样的，就称其为 回文字符串 。

关于预处理所有子串是否回文，已经在上⼀道题目里面讲过，这里就不再赘述啦~

先把回文dp表填好，接下来枚举三个子串除字符串端点外的起止点，查询这三段非空子串是否是回文串。枚举i和j这两条分界线即可，注意区间的闭合问题和J必须要大于等于i。

代码如下：

1. 利用 dp 处理⼀下所有的子串是否回文。

2. 枚举第二个字符串所有的起始位置和终止位置。

写代码希望大家按照1.创建 dp 表2，初始化，3.填表，4.返回值的顺序来进行书写代码，这样不会乱。

class Solution {
    public boolean checkPartitioning(String s) {
        //1.创建 dp 表
        //2.初始化
        //3.填表
        //4.返回值
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        for(int i = n - 1;i >= 0;i--){
            for(int j = i;j < n;j++){
                if(s.charAt(i) == s.charAt(j)){
                    dp[i][j] = i + 1 < j ? dp[i + 1][j - 1] : true;
                }
            }
        }
        boolean ans = false;
        for(int i = 1;i < n;i++){
            for(int j = i;j < n - 1;j++){
                if(dp[0][i - 1] && dp[i][j] && dp[j + 1][n - 1]){
                    ans = true;
                    return ans;
                }

            }
        }
        return false;

    }
}

时间复杂度：O（n^2）

空间复杂度：O（n^2）

例题3：分割回文串II

链接：分割回文串II

题目简介：

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

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

解法（动态规划）：

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]。

代码如下：

其中algorithm就是回文串信息的dp表。

class Solution {
    public int minCut(String s) {
        //1.创建 dp 表
        //2.初始化
        //3.填表
        //4.返回值
        int n = s.length();
        int[] dp = new int[n];
        boolean[][] algorithm = new boolean[n][n];
        for(int i = n - 1;i >= 0;i--){
            for(int j = i;j < n;j++){
                if(s.charAt(i) != s.charAt(j)){
                    algorithm[i][j] = false;
                }else{
                    algorithm[i][j] = i + 1 < j ? algorithm[i + 1][j - 1] : true;
                }
            }
        }
        for(int i = 0;i < n;i++){
            dp[i] = 0x3f3f3f3f;
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j <= i;j++){
                if(algorithm[0][i]){
                    dp[i] = 0;
                    break;
                }else{
                    if(algorithm[j][i]){
                        dp[i] = Math.min(dp[i],dp[j - 1] + 1);
                    }
                }
            }
        }
        return dp[n - 1];
    }
}

时间复杂度：O（n^2）

空间复杂度：O（n^2）

例题4：最长回文子序列

链接：最长回文子序列

题目简介：

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

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

解法（动态规划）：

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] 单独放在⼀个序列的右边，看看这两种情况下的最大值：

1.单独加⼊s[i] 后的区间在[i, j - 1] ，此时最长的回⽂序列的长度就是dp[i] [j - 1] 。

2.单独加⼊s[j] 后的区间在[i + 1, j] ，此时最长的回⽂序列的长度就是dp[i + 1][j] 。

取两者的最大值，于是dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])。

综上所述，状态转移方程为：

（1）当s[i] == s[j] 时： dp[i][j] = dp[i + 1][j - 1] + 2 .

（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 ，我们状态表⽰的时候，选取的是⼀段区间，因此需要要求左端点的值要⼩于等于右端点的值，因此会有两种边界情况：

（1）当i == j 的时候， i + 1 就会大于j - 1 ，此时区间内只有⼀个字符。这个⽐较好分析， dp[i][j] 表示⼀个字符的最长回文序列，⼀个字符能够自己组成回文串，因此此时dp[i][j] = 1。

（2）当i + 1 == j的时候， i + 1 也会大于j - 1 ，此时区间内有两个字符。这样也好分析，当这两个字符相同的时候， dp[i][j] = 2 ；不相同的时候， d[i][j] = 0.

对于第⼀种边界情况，我们在填表的时候，就可以同步处理。

对于第⼆种边界情况， dp[i + 1][j - 1] 的值为0 ，不会影响最终的结果，因此可以不用考虑。

4.填表顺序：

从下往上填写每⼀行。

每⼀行从左往右。

5.返回值：

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

代码如下：

class Solution {
    public int longestPalindromeSubseq(String s) {
        //.创建 dp 表
        //2.初始化
        //3.填表
        //4.返回值
        int n = s.length();
        int[][] dp = new int[n][n];
        for(int i = n - 1;i >= 0;i--){
            //j必须要大于等于i
            for(int j = i;j < n;j++){
                if(s.charAt(i) == s.charAt(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] = Math.max(dp[i][j - 1],dp[i + 1][j]);
                }
            }
        }
        return dp[0][n - 1];
    }
}

时间复杂度：O（n^2）

空间复杂度：O（n^2）

例题5：让字符串成为回文串的最小插入次数

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

题目简介：

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

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

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

解法（动态规划）：

1. 状态表示：

状态表示： dp[i][j]表示字符串[i, j] 区域成为回文子串的最少插入次数。

2.状态转移方程：

根据首尾元素的不同，可以分为下⾯两种情况：

（1）当首尾两个元素相同的时候，也就是s[i] == s[j] ：

1.那么 [i, j] 区间内成为回文子串的最少插⼊次数，取决于[i + 1, j - 1] 区间内成为回文子串的最少插入次数。

2.若 i == j 或i == j - 1（ [i + 1, j - 1] 不构成合法区间），此时只有1 ~2个相同的字符， [i, j] 区间⼀定是回文子串，成为回文子串的最少插入次数是0.

（2）当首尾两个元素不相同的时候，也就是s[i] != s[j] ：

1.此时可以在区间最右边补上⼀个 s[i] ，需要的最少插入次数是 [i + 1, j] 成为回文子串的最少插⼊次数+本次插入，即 dp[i][j] = dp[i + 1][j] + 1 。

2.此时可以在区间最左边补上⼀个 s[j] ，需要的最少插入次数是 [i, j + 1] 成为回文子串的最少插⼊次数+本次插⼊，即 dp[i][j] = dp[i][j + 1] + 1 。

综上所述，状态转移方程为：

（1）当s[i] == s[j]时： dp[i][j] = i >= j - 1 ? 1 : dp[i + 1][j - 1]。

（2）s[i] != s[j]时： dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]) + 1 。

3.初始化：

没有不能递推表示的值，无需初始化。

4.填表顺序：

从下往上填写每⼀行

5.返回值：

返回dp[0][n - 1]。

代码如下：

class Solution {
    public int minInsertions(String s) {
        //1.创建 dp 表
        //2.初始化
        //3.填表
        //4.返回值
        int n = s.length();
        int[][] dp = new int[n][n];
        for(int i = n - 1;i >= 0;i--){
            for(int j = i;j < n;j++){
                if(s.charAt(i) == s.charAt(j)){
                    dp[i][j] = i + 1 < j ? dp[i + 1][j - 1] : 0;
                }else{
                    dp[i][j] = Math.min(dp[i + 1][j] + 1,dp[i][j - 1] + 1);
                }
            }
        }
        return dp[0][n - 1];
    }
}

时间复杂度：O（n^2）

空间复杂度：O（n^2）