LeetCode | C++ 动态规划——647. 回文子串、516.最长回文子序列

647. 回文子串

647题目链接
dp[i] [j]数组定义

表示区间范围[i, j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i] [j]为true，否则为false。

递推公式

分为两种情况：

（1）当s[i] 与 s[j]不相等时， dp[i] [j] 为 false;

（2）当s[i] 与 s[j] 相等时，又分为三种情况：

一：下标 i 与 j 相同时， true

二：下标i 与 j 相差 1 时， true

三：下标i 与 j 相差大于 1 时， 取决于 dp[i + 1] [j - 1]

dp数组初始化

默认初始化为 false

遍历顺序

比较讲究

由递推公式得，dp[i] [j] 由 dp[i + 1] [j - 1]推出来

所以要保证dp[i + 1] [j - 1]都是经过计算的。(i <= j)

具体分为两种：

（1）列优先， 就是先左往右遍历列 j, 再从上往下遍历 i,

（2）行优先，就是先从下往上遍历行 i，再从左往右遍历 j。

class Solution {
public:
    int countSubstrings(string s) {
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int result = 0;
        for (int j = 0; j < s.size(); j++) {
            for (int i = 0; i <= j; i++) {
                if (s[i] == s[j]) {
                    if (i == j) {
                        dp[i][j] = true;
                        result++;
                    } else if (j - i == 1) {
                        dp[i][j] = true;
                        result++;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                        if (dp[i][j] == true) result++;
                    }
                }     
            }
        }
        return result;
    }
};

516.最长回文子序列

516题目链接
注意：子序列与子串的区别，子序列可以是不连续的，而子串要求是连续的。

dp[i] [j]数组定义

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

递推公式

分两种情况：

（1）当s[i] 与 s[j] 相同时，

dp[i] [j] = dp[i + 1] [j - 1] + 2;

（2）当s[i] 与 s[j] 不相同时，则同时加入 s[i] 和 s[j]无法增加回文子序列长度，所以分别加入s[i] 和 s[j]

加入s[i], dp[i] [j] = dp[i] [j - 1]

加入s[j], dp[i] [j] = dp[i + 1] [j]

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

dp数组初始化

根据递推公式 需要将 dp 数组 最左边 和 对角线 （因为 i <= j） 的元素进行初始化

当 i 和 j 相同时，从递推公式可以看出，无法计算，需要手动初始化，赋值为 1

对于最左边元素（dp[i] [0]），根据定义 赋值为 0

遍历顺序

由递推公式得：

所以遍历顺序 从下往上， 从左到右

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