【代码随想录】Day57 动态规划17 （回文子串、最长回文子序列）

Pearl。

已于 2023-09-08 17:39:34 修改

阅读量124

点赞数

文章标签：动态规划算法

于 2023-09-05 23:29:52 首次发布

本文链接：https://blog.csdn.net/weixin_43785314/article/details/132702410

版权

文章讲述了在LeetCode网站上两个与动态规划相关的问题：一个是计算给定字符串中连续子串的回文数量，另一个是寻找最长的回文子串。通过二维dp数组实现算法，展示了如何从下往上、从左往右推导并求解这两个问题。

摘要由CSDN通过智能技术生成

第一题

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

二维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 ((j-i) <= 1) {
                        dp[i][j] = true;
                        res++;
                    }
                    else if (dp[i+1][j-1] == true) {
                        dp[i][j] = true;
                        res++;
                    }
                }
                
            }
        }
        return res;
    }

第二题

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

dp[i][j]，i到j范围内的回文子序列长度

if (s[i] == s[j]) dp[i][j] = dp[i+1][j-1] + 2;

else dp[i][j] = max(dp[i][j-1] + 1, dp[i+1][j]);

if (i == j) dp[i][j] = 1;

最长回文子串

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
public:
    string longestPalindrome(string s) {
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int maxLen = 1, maxIndex = 0;
        for (int i = 0; i < s.size(); i++) {
            dp[i][i] = true;
        }
        for (int i = s.size()-1; i >= 0; i--) {
            for (int j = i+1; j < s.size(); j++) {
                if (s[i] == s[j]) {
                    if (j - i <= 1) {
                        dp[i][j] = true;
                    }
                    else if (dp[i+1][j-1] == true) {
                        dp[i][j] = true;
                    }
                    if (dp[i][j] == true  && (j - i + 1) > maxLen) {//只有当最长长度更新的时候，maxIndex才更新！！!
                    //并且！只有当s[i]==s[j]时,dp[i][j]才有可能是回文，所以一定要写在里面
                        maxLen = j - i + 1;
                        maxIndex = i;
                    }
                }
                
            }
        }
        return s.substr(maxIndex, maxLen);
    }
};