代码随想录算法训练营day57|第九章 动态规划part17

目录

647. 回文子串   

516.最长回文子序列 

动态规划总结篇 

---

 

647. 回文子串   

动态规划解决的经典题目，如果没接触过的话，别硬想 直接看题解。

代码随想录

这道题对dp数组的定义就很特别，事实上，对于dp数组的定义一般会和题目所要求的东西有关，但这道题不同，因为不难发现dp[i] 和 dp[i-1] ，dp[i + 1] 看上去都没啥关系。但是仔细考虑会发现一种递推关系，也就是判断一个子字符串（字符串的下表范围[i,j]）是否回文，依赖于它的子字符串（下表范围[i + 1, j - 1]）） 是否是回文，如果子字符串回文，那只要判定两端的字符是否相等即可。由此也可见，只凭借一维数组是没办法同时反映左端点和右端点两个要素的，故而需要使用二维数组，因为依赖关系是“是否”，所以必然要使用bool类型的dp数组，dp[i][j]表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。

递推公式还是依据上面来看还是要先判断两个字符是否相等，因为如果两端的字符不相等，那就一定不能构成回文串，只有相等才能进一步判定；相等，那就判断两端点所涵盖的字符个数，如果只包含一个字符或两个字符，内部根本不可能有别的回文子串，那就直接判定是回文子串，而如果不止，那就要判断dp[i+1][j-1]是否为true，也就是内部是否是回文子串。

这个递推公式需要从左下角来推导当前元素的值，所以必然要正向遍历j，反向便利 i，而且因为 i 代表左端点、j 表示右端点，所以必然要 j>=i ，也就是 j 从 i 开始向后遍历。涉及到初始化的问题，因为没有正式判断之前是不能武断地确认当前子串是回文子串的，所以必然要全部初始化为false。

注意还要用res来捡拾结果。

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--) {  // 注意遍历顺序
            for (int j = i; j < s.size(); j++) {
                if (s[i] == s[j]) {
                    if (j - i <= 1) { // 情况一 和 情况二
                        result++;
                        dp[i][j] = true;
                    } else if (dp[i + 1][j - 1]) { // 情况三
                        result++;
                        dp[i][j] = true;
                    }
                }
            }
        }
        return result;
    }

实际上用动态规划来做空间上消耗太大，这道题也可以使用双指针来做。每一个回文子串必然有一个中心点，这个中心点有可能是一个值、有可能两个值（看字符串长度奇偶数），但是从中心点向两端延申必然对应的字符是相等的，注意奇字符串一定和偶字符串不相同，所以要分开考虑。

class Solution {
public:
    int countSubstrings(string s) {
        int res=0;
        for(int i=0;i<s.size();i++){
            res+=extend(s,i,i,s.size());
            res+=extend(s,i,i+1,s.size());
        }
        return res;
    }
    int extend(string& s,int i,int j,int n){
        int res=0;
        while(i>=0&&j<n&&s[i]==s[j]){
            i--;
            j++;
            res++;
        }
        return res;
    }
};

516.最长回文子序列 

 647. 回文子串，求的是回文子串，而本题要求的是回文子序列， 大家要搞清楚两者之间的区别。 

代码随想录

这道题dp数组的含义是字符串s在[i, j]范围内最长的回文子序列的长度。思路和上一题有点像，还是要用 i 作为子字符串的左端点， j 作为子字符串的右端点，但是这回遇到两端字符相等的情况，就直接让dp数组在原来的基础上加2（所谓原来的基础自然是两个指针各往中间缩一格的值），直接加2，是因为已经事先判定好了左右端点所包含的字符一定不小于3个，这就同时要求j从 i+1 处开始遍历，也同时要求dp[ i ][ i ]在初始化的时候就赋值为1；而如果不相等，那就删除左端点的字符或者删除右端点的字符，也就是不同时让两个指针向中心处靠近一格，比较哪种情况的值更大。

至于遍历顺序，这道题当前值可以从它的左边、下边和左下角推导出来，所以整体的遍历顺序和上题的一样。初始化时候，考虑当i 和j 相同的情况，由于递推公式：dp[i][j] = dp[i + 1][j - 1] + 2，看出递推公式是计算不到 i 和j相同时候的情况。所以需要手动初始化一下，当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1。其他情况dp[i][j]初始为0就行，这样递推公式：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]) 中dp[i][j]才不会被初始值覆盖(次要原因是剩下的值你也确实不知道是几)。

虽然文章中的 i 是从s.size()-1开始，但实际上因为 j 从 i + 1开始遍历，所以 i 第1遍循环是不会有任何结果产生的，实际上 i 也可以从s.size()-2开始遍历。除此之外，每次 j 的遍历里面第1次执行dp[i][j] = dp[i + 1][j - 1] + 2，所用的之前的值dp[i + 1][j - 1]实际上为0( j 从 i + 1开始遍历，每次恰好错过初始化这个值)，所以在仅有两个元素的时候，如果这两个元素恰好相等或不相等，都能按照这种递推方式来推导当前值。

至于最后收集结果，注意dp数组的含义是字符串s在[i, j]范围内最长的回文子序列的长度，所以最大值必然在[0, s.size()-1]范围内。

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

动态规划总结篇 

代码随想录

动规五部曲分别为：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

 动态规划的问题主要有：背包问题系列、打家劫舍系列、股票系列、子序列系列。