回文子串

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

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

示例 1：

• 输入：“abc”
• 输出：3
• 解释：三个回文子串: “a”, “b”, “c”

示例 2：

• 输入：“aaa”
• 输出：6
• 解释：6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”

提示：输入的字符串长度不会超过 1000 。

​ 动规五部曲

​ 首先想到的自然是一维数组，但是找不到dp[i - 1]与dp[i]的关系；所以考虑二维dp数组

​ 1.dp数组及其下标含义

​ dp[i][j]表示区间[i, j]的子字符串(连续)为回文子串；

​ 2.递推公式

​ 显然，这里有一个最基本的情形；如果[i + 1, j -1]区间已经成立，在s[i] == s[j]时，[i, j]区间也是回文串；

	if(s[i] == s[j]){
        if(i == j || i = j - 1){//单个元素的子序列或者长度为2但相等的子序列一定是回文串
            dp[i][j] = true;
            res++;
        }
        else if(dp[i + 1][j - 1] == true){
            dp[i][j] = true;
            res++;
        }
    }

​ 3.初始化

	vector<vector<bool>> dp(str.size(), vector<bool>(str.size(), false));//默认为false递推公式则不需要讨论不同的情况

​ 4.遍历顺序

​ 由于dp[i][j]是由dp[i + 1][j - 1]（左下角推出）；

​ 所以需要从下往上，从左往右遍历；

​ 5.打印dp

​ 整体代码如下:

	int countSubstrings(string s){
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int res = 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 || i == j - 1){//单个元素的子序列或者长度为2但相等的子序列一定是回文串
                        dp[i][j] = true;
                        res++;
                    }
                    else if(dp[i + 1][j - 1] == true){
                        dp[i][j] = true;
                        res++;
                    }
                }
                //if (s[i] == s[j] && (j - i <= 1 || dp[i + 1][j - 1])) {
                //    result++;
                //    dp[i][j] = true;
                //}                
            }
        }
        return res;
    }

最长回文子序列

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

示例 1: 输入: “bbbab” 输出: 4 一个可能的最长回文子序列为 “bbbb”。

示例 2: 输入:“cbbd” 输出: 2 一个可能的最长回文子序列为 “bb”。

提示：

• 1 <= s.length <= 1000
• s 只包含小写英文字母

​ 回文子串是要连续的，回文子序列可不是连续的

​ 动规五部曲

​ 1.dp数组下标及其含义

​ dp[i][j]表示区间[i, j]的子序列(可不连续)中的回文子串的长度；

​ 2.递推公式

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

​ 3.初始化

​ 由递推公式，dp[i][j]无法由dp[i - 1][j - 1]推出，考虑dp[i][j]中i j相同时，初始化为1；其余的为0即可

	vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
	for(int i = 0; i < s.size(); i++) dp[i][i] = 1;

​ 4.遍历顺序

​ 由递推公式，遍历是由从左下方、下方、左方推导而来；所以遍历顺序应该是从下往上，从左往右；

​ 5.打印dp

​ 整体代码如下：

	 int longestPalindromeSubseq(string s){
         vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
         for(int i = 0; i < s.size(); i++) dp[i][i] = 1;
         for(int i = s.size() - 1; i >= 0; i--){
             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];
     }