算法专题：子序列系列2（回文）

回文串系列，主要在于DP数组定义，与递推过程中的遍历顺序，与之前的子序列差别比较大。

示例1：回文子串

647. 回文子串 - 力扣（LeetCode）

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

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

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

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

示例 1：

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

示例 2：

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

提示：

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

思路

如果做了很多这种子序列相关的DP题目，在定义dp数组的时候 很自然就会想题目求什么，我们就如何定义dp数组。绝大多数题目确实是这样，不过本题如果我们定义dp[i] 为 下标i结尾的字符串有 dp[i]个回文串的话，我们会发现很难找到递归关系。

因为dp[i] 和 dp[i-1] ，dp[i + 1] 看上去都没啥关系。所以我们要看回文串的性质。

判断字符串S是否是回文，如果我们知道 s[1]，s[2]，s[3] 这个子串是回文的，那么只需要比较 s[0]和s[4]这两个元素是否相同，如果相同的话，这个字符串s 就是回文串。

因此，递归关系是，判断一个子字符串（字符串的下表范围[i,j]）是否回文，依赖于子字符串（下表范围[i + 1, j - 1]）） 是否是回文。

DP数组含义（注意）

bool型dp[i][j]：表示如果起点为i，终点为j的区间，该区间的子串是回文串 （注意是左闭右闭），那么dp[i][j]为true，否则为false。

递推公式

判断区间[i,j]构成的子串是不是回文串，只有三种情况：

• i=j，也就是本身的情况，一个字符本身是一个回文串，对应"a"的情况
• j-i=1，也就是i和j相邻的情况，那么相邻的两个字符，构成一个回文串，也就是"aa"的情况
• dp[i+1][j-1]是一个回文串，也就是”aba“的情况

if(s[j]==s[i]){
    if((j-i)<=1){//包括了j=i和j-i=1的情况，也就是相邻的情况和重合(只有一个)的情况
        result++;
        dp[i][j]=true;
    }
    else if(dp[i+1][j-1]){
        result++;//外层多了一个也是回文串，结果+1
        dp[i][j]=true;
    }
}

初始化

vector<vector<bool>>dp(s.size(),vector<bool>(s.size(),false));

遍历顺序（注意）

注意，在本题中，是通过dp[i+1][j-1]来推出dp[i][j]的状态，因此i的状态要通过i+1来推出。因此i的遍历必须是倒序遍历。

同时，j是从j-1状态推出来，因此j的遍历是正序遍历。

for(int i=s.size();i>=0;i--){
    for(int j=i;j<s.size();j++){
        if(s[j]==s[i]){
            if((j-i)<=1){//字符本身，或者是相邻字符
                result++;
                dp[i][j]=true;
            }
            else if(dp[i+1][j-1]){//内部相等
                result++;
                dp[i][j]=true;
            }
        }
    }
}

完整版

class Solution {
public:
    int countSubstrings(string s) {
        vector<vector<bool>>dp(s.size(),vector<bool>(s.size(),false));
        int result=0;
        for(int i=s.size()-1;i>=0;i--){//倒序的时候i的范围是[0,s.size()-1]！
            for(int j=i;j<s.size();j++){
                if(s[j]==s[i]){
                    if((j-i)<=1){//这里包含了两种情况，(j-i)=1的情况和j=i的情况
                        result++;
                        dp[i][j]=true;
                    }
                    else if(dp[i+1][j-1]){
                        result++;//外层相等也是多了一个回文串
                        dp[i][j]=true;
                    }
                }
            }
        }
		return result;
    }
};

注意点

• 倒序遍历的时候i的范围是[0,s.size()-1]，也就是说倒序结束条件应该是i>=0！
• 回文串主要是情况分析。是回文的情况只有三种：
  • i=j，也就是本身的情况，一个字符本身是一个回文串，对应"a"的情况
  • j-i=1，也就是i和j相邻的情况，那么相邻的两个字符，构成一个回文串，也就是"aa"的情况
  • dp[i+1][j-1]是一个回文串，也就是”aba“的情况

分析完这三种之后再写递推，递推就比较好写了。

示例2：最长回文子序列

516. 最长回文子序列 - 力扣（LeetCode）

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

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

示例 1：

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

示例 2：

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

提示：

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

思路

本题是不连续的，但是DP数组依然是按照回文系列定义[i,j]区间的方式来定义。

DP数组含义

字符串s在[i,j]范围内，最长回文子序列的长度为dp[i][j]

递推公式

在判断回文子串的题目中，关键逻辑就是看s[i]与s[j]是否相同。

如果相同，那么在dp[i+1][j-1]的基础上**+2**。(此时还有j=i的情况，j=i应该+1)

如果不相同，那么就在不包含的两种情况（不包含s[i]或者不包含s[j]）中选择最大值。

for(int i=s.size()-1;i>=0;i--){
    for(int j=i;j<s.size();j){
        if(s[i]==s[j]){
            if(i=j) dp[i][j]=1;//注意DP数组的定义，是区间[i,j]内回文子序列最大长度！
            else if(j>0)
            	dp[i][j]=dp[i+1][j-1]+2;
        }
        else{
            dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
        }
    }
}

初始化

vector<vector<int>>dp(s.size(),vector<int>(s.size(),0));

遍历顺序

遍历顺序同上一题，i是倒序遍历，j是正序遍历，且j>i（本题不是j>=i了，因为长度累加+2）

完整版

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>>dp(s.size(),vector<int>(s.size(),0));
		int result=0;
        for(int i=s.size()-1;i>=0;i--){
    		for(int j=i;j<s.size();j++){
        		if(s[i]==s[j]){
            		if(i==j) dp[i][j]=1;//注意DP数组的定义，是区间[i,j]内回文子序列最大长度！
            		else if(j>0)
            			dp[i][j]=dp[i+1][j-1]+2;
        		}
        		else{
            		dp[i][j]=max(dp[i+1][j],dp[i][j-1]);//一定要注意，这里是从[i+1,j]和[i,j-1]里面取值，因为i是倒序遍历，j是正序遍历
        		}
                result=max(result,dp[i][j]);
    		}
		}
        return result;
    }
};

注意点

• 注意本题是求回文子串内部最大长度，而且不连续，因此本题j=i和j!=i的情况就需要分开。
• j=i的情况是长度+1，j!=i且s[j]==s[i]的情况，是长度+2。
• 遍历顺序和不等情况下的取值也有关系，如果是不等的情况，那么去除当前取值应该在[i+1,j-1]的范围里面取！

另一种写法

• 也可以在初始化的时候，单独处理i=j的情况，令dp[i][i]=1

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        //vector> dp(s.size(), vector(s.size(), 1));
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));//不能用1来初始化二维数组，需要用0，为了避免s[i]!=s[j]但是dp[i][j]=1的情况
        for(int i=0;i<s.size();i++){
            dp[i][i]=1;
        }
        for (int i = s.size() - 1; i >= 0; i--) {
			//j直接从i+1开始，只处理+2的情况
            for (int j = i + 1; j < s.size(); 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][s.size() - 1];
    }
};

不能把DP数组全部初始化为1的原因

dp[i][j]表示从索引i到索引j的字符串的最长回文子序列的长度。

如果字符串s[i]和s[j]不相等，且j=i+1，如果直接让dp[i][j]的值为1，但实际上，因为s[i]和s[j]不相等，所以它们不可能构成一个回文子序列，dp[i][j]应当为0。

dp[i][j]应该被初始化为0，因为在默认情况下，如果没有找到任何回文子序列，那么回文子序列的长度应该为0。只有当i等于j时，也就是只有一个字符的时候，我们才把dp[i][j]设置为1，因为单个字符自身就是一个长度为1的回文子序列。