参考

代码随想录

题目一：LeetCode 647. 回文子串

如果用暴力求解，两层for循环加一层判断，两个遍历指针i和j构成一个区间，每次判断这个区间内的字符串是否为回文串，这样的求法时间复杂度为O(n^3)。这里使用动态规划可以将判断i和j区间的字符串是否为回文串的时间复杂度降为O(1).

如上图所示，如果使用暴力解法，那么需要遍历[i,j]区间中的每个字符，但使用动态规划就不需要遍历这个区间内的所有字符了，只需要判断s[i]和s[j]是否相等，前提是要先记录[i+1,j-1]区间内的情况，因此需要占用额外的空间，也就是用空间换取时间的方法。因为判断[i,j]区间的字符串是否为回文串就需要先知道[i+1,j-1]区间内的字符串是否为回文串，因此整个区间要先从最右边开始“扩张”，即i从最右边开始向左移动，j指针从i开始向右移动。

确定dp数组下标及其含义
dp[i][j]：如果[i,j]区间内的字符串为回文串，则dp[i][j]为true，否则为false。
确定递推公式

如果s[i] != s[j]，则[i,j]内的字符串必定不是回文串，即dp[i][j] = false.
如果s[i] == s[j]，则需要分为三种情况：
（1）i == j，即区间内只有一个字符，因此dp[i][j] = true
（2）i + 1 = j，即区间内只有两个字符，因此是回文串，dp[i][j] = true
（3）i + 1 < j，即区间内多于两个字符，此时是否为回文串要看dp[i+1][j-1]，如果dp[i+1][j-1]为true，则是回文串，否则不是

综上所述，递推公式的代码实现为：

if(s[i] != s[j])
   dp[i][j] = false;
else{
    if(i == j || i + 1 == j || ((i + 1 < j) && dp[i+1][j-1] == true)){	//三种为true的情况
        dp[i][j] = true;
        result ++;
    }
    else
        dp[i][j] = false;
}

确定遍历顺序
从之前的分析就提到，[i,j]区间内字符串的判断可能要依赖[i+1,j-1]区间的判断结果，因此整个区间必定是要从最右边开始向左移动，因此i从大到小，j从i开始递增。
初始化dp数组
根据递推公式，似乎需要初始化dp数组，但其实可以不初始化，因为只有[i,j]区间内的元素多于两个时候才需要用到dp[i+1][j-1]，当[i,j]区间只有一个或两个元素的时候直接就能得到结论，因此可以看作初始化过程已经包含在遍历过程中了，因此不需要额外初始化。
举例推导dp数组

可以看出，因为i <= j，因此dp数组只用到了对角线及右上半部分，图中有6个true，因此有6个回文子串。

完整的代码实现如下：

class Solution {
public:
    int countSubstrings(string s) {
        int result = 0;
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size()));
        for(int i = s.size(); i >= 0; i--){
            for(int j = i; j < s.size(); j++){
                if(s[i] != s[j])
                    dp[i][j] = false;
                else{
                    if(i == j || i + 1 == j || ((i + 1 < j) && dp[i+1][j-1] == true)){	//三种为true的情况
                        dp[i][j] = true;
                        result ++;
                    }
                    else
                        dp[i][j] = false;
                }
            }
        }
        return result;
    }
};

题目二：LeetCode 516.最长回文子序列

确定dp数组下标及其含义
dp[i][j]：字符串s中[i,j]区间构成的字符串中的最长回文子串的长度为dp[i][j]。
确定递推公式

如果s[i] == s[j]，则dp[i][j] = dp[i+1][j-1] + 2，其中的加2就是新加入的两个相等的字符
如果s[i] != s[j]，说明同时加入s[i]和s[j]并不能增加回文子序列的长度，那么如果加入s[i]，则回文串的最大长度为dp[i][j-1]，如果加入s[j]，那么dp[i+1][j]，最终要取最大，即dp[i][j] = max(dp[i][j-1],dp[i+1][j]。为什么do[i][j] = dp[i-1][j-1]的情况？因为dp[i][j] <= dp[i][j-1]且dp[i][j] <= dp[i+1][j]，因此dp[i][j-1]和dp[i+1][j]已经涵盖了dp[i-1][j-1]。

代码如下：

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

初始化dp数组
初始化要结合下图理解。因为要满足i <= j，所以似乎do数组只有下图中的阴影部分有用。

根据递推关系，dp[i][j]会涉及到下图中的几个区域：

当i == j或者i + 1 = j，即区间中只有一个或者两个字符，此时dp[i][j]所依赖的元素就会在对角线的左下半部分，如下图所示：

因为当i == j时，dp[i][j]确定等于1，因此在初始化时就将i == j的情况赋值，在遍历时就不考虑了。
当i + 1 == j时，区间内有两个字符，如果两个字符相等，则dp[i][j] = 2，否则dp[i][j] = 1。套用递推公式，如果s[i] == s[j]，则dp[i][j] = dp[i+1][j-1] + 2 = 2，推出dp[i+1][j-1] = 0，根据 i + 1 == j，dp[i+1][j-1]是下图中的阴影部分，这部分应该初始化为0。

如果s[i] != s[j]，则dp[i][j] = max(dp[i+1][j],dp[i][j-1]) = 1，同样因为 i + 1 == j，所以此时的dp[i+1][j]和dp[i][j-1]是dp数组的对角线，所以对角线应该初始化为1，和只有一个元素时的情况一样，没有矛盾，所以可以一起处理。

综上所述，dp数组的初始化如下图所示（其余不用初始化）：

为了方便，其余都初始化为0。

确定遍历顺序
根据递推公式的依赖关系（如下图所示），i要从大到小，j要从小到大。
举例推导dp数组

完整的代码实现如下：

class Solution {
public:
    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].back();
    }
};