1 回文子串

1.1 题目链接

647. 回文子串

1.2 题目描述

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

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

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

 

示例 1：

输入： s = "abc"
输出： 3
解释： 三个回文子串: "a", "b", "c"

示例 2：

输入： s = "aaa"
输出： 6
解释： 6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

 

提示：

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

1.3 解法（动态规划）

算法思路：

我们可以先「预处理」⼀下，将所有⼦串「是否回⽂」的信息统计在 dp 表⾥⾯，然后直接在表⾥⾯统计 true 的个数即可。

1. 状态表⽰：

   为了能表⽰出来所有的⼦串，我们可以创建⼀个 n * n 的⼆维 dp 表，只⽤到「上三⻆部分」即可。其中， dp[i][j] 表⽰： s 字符串 [i, j] 的⼦串，是否是回⽂串。

2. 状态转移⽅程：

• 对于回⽂串，我们⼀般分析⼀个「区间两头」的元素：
  • i. 当 s[i] != s[j] 的时候：不可能是回⽂串， dp[i][j] = 0 ；
  • ii. 当 s[i] == s[j] 的时候：根据⻓度分三种情况讨论：
    • ⻓度为 1 ，也就是 i == j ：此时⼀定是回⽂串， dp[i][j] = true ；
    • ⻓度为 2 ，也就是 i + 1 == j ：此时也⼀定是回⽂串， dp[i][j] = true ；
    • ⻓度⼤于 2 ，此时要去看看 [i + 1, j - 1] 区间的⼦串是否回⽂： dp[i][j] = dp[i + 1][j - 1] 。
• 综上，状态转移⽅程分情况谈论即可。

3. 初始化：

   因为我们的状态转移⽅程分析的很细致，因此⽆需初始化。

4. 填表顺序：

   根据「状态转移⽅程」，我们需要「从下往上」填写每⼀⾏，每⼀⾏的顺序⽆所谓。

5. 返回值：

   根据「状态表⽰和题⽬要求」，我们需要返回 dp 表中 true 的个数。

1.4 C++算法代码：

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])
                    ret++;
            }
        }
        return ret;
    }
};

2 最长回文子串

2.1 题目链接

5. 最长回文子串

2.2 题目描述

给你一个字符串 s，找到 s 中最长的 回文(如果字符串向前和向后读都相同，则它满足 回文性。) 子串(子字符串 是字符串中连续的 非空 字符序列。)。

 

示例 1：

输入： s = "babad"
输出： "bab"
解释： "aba" 同样是符合题意的答案。

示例 2：

输入： s = "cbbd"
输出： "bb"

 

提示：

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

2.3 解法（动态规划）

算法思路：

• a. 我们可以先⽤ dp 表统计出「所有⼦串是否回⽂」的信息

• b. 然后根据 dp 表⽰ true 的位置，得到回⽂串的「起始位置」和「⻓度」。

  那么我们就可以在表中找出最⻓回⽂串。

  关于「预处理所有⼦串是否回⽂」，已经在上⼀道题⽬⾥⾯讲过，这⾥就不再赘述啦~

2.4 C++算法代码：

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

        int len = 1, begin = 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] && j - i + 1 > len)
                    len = j - i + 1, begin = i;
            }
        }
        return s.substr(begin, len);
    }
};

3 分割回文串 IV

3.1 题目链接

1745. 分割回文串 IV

3.2 题目描述

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

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

 

示例 1：

输入： s = "abcbdd"
输出： true
解释： "abcbdd" = "a" + "bcb" + "dd"，三个子字符串都是回文的。

示例 2：

输入： s = "bcbddxy"
输出： false
解释： s 没办法被分割成 3 个回文子字符串。

 

提示：

• 3 <= s.length <= 2000
• s​​​​​​ 只包含小写英文字母。

3.3 解法（动态规划）

算法思路：

题⽬要求⼀个字符串被分成「三个⾮空回⽂⼦串」，乍⼀看，要表⽰的状态很多，有些⽆从下⼿。

• 其实，我们可以把它拆成「两个⼩问题」：

  • i. 动态规划求解字符串中的⼀段⾮空⼦串是否是回⽂串；
  • ii. 枚举三个⼦串除字符串端点外的起⽌点，查询这三段⾮空⼦串是否是回⽂串。

  那么这道困难题就免秒变为简单题啦，变成了⼀道枚举题。

  关于预处理所有⼦串是否回⽂，已经在上⼀道题⽬⾥⾯讲过，这⾥就不再赘述啦~

3.4 C++算法代码：

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

        int len = 1, begin = 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;

        // 枚举所有的第二个字符串的起始位置以及结束位置
        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;
    }
};

4 分割回文串 II

4.1 题目链接

132. 分割回文串 II

4.2 题目描述

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

回文串

。

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

 

示例 1：

输入： s = "aab"
输出： 1
解释： 只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

示例 2：

输入： s = "a"
输出： 0

示例 3：

输入： s = "ab"
输出： 1

 

提示：

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

4.3 解法（动态规划）

算法思路：

1. 状态表⽰：

   • 根据「经验」，继续尝试⽤ i 位置为结尾，定义状态表⽰，看看能否解决问题：
     • dp[i] 表⽰： s 中 [0, i] 区间上的字符串，最少分割的次数。

2. 状态转移⽅程：

   • 状态转移⽅程⼀般都是根据「最后⼀个位置」的信息来分析：设 0 <= j <= i ，那么我们可以根据 j ~ i 位置上的⼦串是否是回⽂串分成下⾯两类：
     • i. 当 [j ,i] 位置上的⼦串能够构成⼀个回⽂串，那么 dp[i] 就等于 [0, j - 1] 区间上最少回⽂串的个数 + 1，即 dp[i] = dp[j - 1] + 1 ；
     • ii. 当 [j ,i] 位置上的⼦串不能构成⼀个回⽂串，此时 j 位置就不⽤考虑。
   • 由于我们要的是最⼩值，因此应该循环遍历⼀遍 j 的取值，拿到⾥⾯的最⼩值即可。

优化：我们在状态转移⽅程⾥⾯分析到，要能够快速判读字符串⾥⾯的⼦串是否回⽂。因此，我们可以先处理⼀个 dp 表，⾥⾯保存所有⼦串是否回⽂的信息。

3. 初始化：

   • 观察「状态转移⽅程」，我们会⽤到 j - 1 位置的值。我们可以思考⼀下当 j == 0 的时候，表⽰的区间就是 [0, i] 。如果 [0, i] 区间上的字符串已经是回⽂串了，最⼩的回⽂串就是 1 了， j 往后的值就不⽤遍历了。
   • 因此，我们可以在循环遍历 j 的值之前处理 j == 0 的情况，然后 j 从 1 开始循环。
   • 但是，为了防⽌求 min 操作时， 0 ⼲扰结果。我们先把表⾥⾯的值初始化为「⽆穷⼤」。

4. 填表顺序：

   毫⽆疑问是「从左往右」。

5. 返回值：

   根据「状态表⽰」，应该返回 dp[n - 1] 。

4.4 C++算法代码：

class Solution {
public:
    int minCut(string s) {
        int n = s.size();
        vector<vector<bool>> isPal(n, vector<bool>(n));

        int len = 1, begin = 0;
        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);
        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];
    }
};

5 最长回文子序列

5.1 题目链接

516. 最长回文子序列

5.2 题目描述

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

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

 

示例 1：

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

示例 2：

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

 

提示：

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

5.3 解法（动态规划）

算法思路：

1. 状态表⽰：

   • 关于「单个字符串」问题中的「回⽂⼦序列」，或者「回⽂⼦串」，我们的状态表⽰研究的对象⼀般都是选取原字符串中的⼀段区域 [i, j] 内部的情况。这⾥我们继续选取字符串中的⼀段区域来研究：
     • dp[i][j] 表⽰：s 字符串 [i, j] 区间内的所有的⼦序列中，最⻓的回⽂⼦序列的⻓度。

2. 状态转移⽅程：

   • 关于「回⽂⼦序列」和「回⽂⼦串」的分析⽅式，⼀般都是⽐较固定的，都是选择这段区域的「左右端点」的字符情况来分析。因为如果⼀个序列是回⽂串的话，「去掉⾸尾两个元素之后依旧是回⽂串」，「⾸尾加上两个相同的元素之后也依旧是回⽂串」。因为，根据「⾸尾元素」的不同，可以分为下⾯两种情况：
     • i. 当⾸尾两个元素「相同」的时候，也就是 s[i] == s[j] ：那么 [i, j] 区间上的最⻓回⽂⼦序列，应该是 [i + 1, j - 1] 区间内的那个最⻓回⽂⼦序列⾸尾填上 s[i] 和 s[j] ，此时 dp[i][j] = dp[i + 1][j - 1] + 2
     • ii. 当⾸尾两个元素不「相同」的时候，也就是 s[i] != s[j] ：此时这两个元素就不能同时添加在⼀个回⽂串的左右，那么我们就应该让 s[i] 单独加在⼀个序列的左边，或者让 s[j] 单独放在⼀个序列的右边，看看这两种情况下的最⼤值：
       • 单独加⼊ s[i] 后的区间在 [i, j - 1] ，此时最⻓的回⽂序列的⻓度就是 dp[i][j - 1] ；
       • 单独加⼊ s[j] 后的区间在 [i + 1, j] ，此时最⻓的回⽂序列的⻓度就是 dp[i + 1][j] ；取两者的最⼤值，于是 dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])
   • 综上所述，状态转移⽅程为：
     • 当 s[i] == s[j] 时： dp[i][j] = dp[i + 1][j - 1] + 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 ，我们状态表⽰的时候，选取的是⼀段区间，因此需要要求左端点的值要⼩于等于右端点的值，因此会有两种边界情况：
     • i. 当 i == j 的时候， i + 1 就会⼤于 j - 1 ，此时区间内只有⼀个字符。这个⽐较好分析， dp[i][j] 表⽰⼀个字符的最⻓回⽂序列，⼀个字符能够⾃⼰组成回⽂串，因此此时 dp[i][j] = 1 ；
     • ii. 当 i + 1 == j 的时候， i + 1 也会⼤于 j - 1 ，此时区间内有两个字符。这样也好分析，当这两个字符相同的时候， dp[i][j] = 2 ；不相同的时候， d[i][j] = 0 。
   • 对于第⼀种边界情况，我们在填表的时候，就可以同步处理。
   • 对于第⼆种边界情况， dp[i + 1][j - 1] 的值为 0 ，不会影响最终的结果，因此可以不⽤考虑。

4. 填表顺序：

   • 根据「状态转移」，我们发现，在 dp 表所表⽰的矩阵中， dp[i + 1] 表⽰下⼀⾏的位置，dp[j - 1] 表⽰前⼀列的位置。因此我们的填表顺序应该是「从下往上填写每⼀⾏」，「每⼀⾏从左往右」。
   • 这个与我们⼀般的填写顺序不太⼀致。

5. 返回值：

   根据「状态表⽰」，我们需要返回 [0, n -1] 区域上的最⻓回⽂序列的⻓度，因此需要返回 dp[0][n - 1] 。

5.4 C++算法代码：

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

        for(int i = n - 1; i >= 0; i--)
        {
            dp[i][i] = 1;
            for(int j = i + 1; j < n; j++)
            {
                if(s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1] + 2;
                else dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
            }
        }
        return dp[0][n - 1];
    }
};

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

6.1 题目链接

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

6.2 题目描述

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

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

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

 

示例 1：

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

示例 2：

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

示例 3：

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

6.3 解法（动态规划）

算法思路：

1. 状态表⽰：

   • 关于「单个字符串」问题中的「回⽂⼦序列」，或者「回⽂⼦串」，我们的状态表⽰研究的对象⼀般都是选取原字符串中的⼀段区域 [i, j] 内部的情况。这⾥我们继续选取字符串中的⼀段区域来研究：
   • 状态表⽰： dp[i][j] 表⽰字符串 [i, j] 区域成为回⽂⼦串的最少插⼊次数。

2. 状态转移⽅程：

   • 关于「回⽂⼦序列」和「回⽂⼦串」的分析⽅式，⼀般都是⽐较固定的，都是选择这段区域的「左右端点」的字符情况来分析。因为如果⼀个序列是回⽂串的话，「去掉⾸尾两个元素之后依旧是回⽂串」，「⾸尾加上两个相同的元素之后也依旧是回⽂串」。因为，根据「⾸尾元素」的不同，可以分为下⾯两种情况：
     • i. 当⾸尾两个元素「相同」的时候，也就是 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
     • 此时 。dp[i][j] = i >= j - 1 ? 0 : dp[i + 1][j - 1] ；
     • ii. 当⾸尾两个元素「不相同」的时候，也就是 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 ；
   • 综上所述，状态转移⽅程为：
     • 当 s[i] == s[j] 时： dp[i][j] = i >= j - 1 ? 1 : dp[i + 1][j -1]
     • 当 s[i] != s[j] 时： dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]) + 1 。

3. 初始化：

   根据「状态转移⽅程」，没有不能递推表⽰的值。⽆需初始化。

4. 填表顺序：

   • 根据「状态转移」，我们发现，在 dp 表所表⽰的矩阵中， dp[i + 1] 表⽰下⼀⾏的位置， dp[j - 1] 表⽰前⼀列的位置。因此我们的填表顺序应该是「从下往上填写每⼀⾏」，「每⼀⾏从左往右」。
     • 这个与我们⼀般的填写顺序不太⼀致。

5. 返回值：

   根据「状态表⽰」，我们需要返回 [0, n -1] 区域上成为回⽂⼦串的最少插⼊次数，因此需要返回 dp[0][n - 1] 。

6.4 C++算法代码：

class Solution {
public:
    int minInsertions(string s) {
        int n = s.size();
        vector<vector<int>> dp(n, 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];
    }
};