代码随想录算法训练营Day52|647.回文子串、516.最长回文子序列

回文子串

647. 回文子串 - 力扣（LeetCode）

暴力解法

遍历字符串中的所有子串，并判断是否为回文串，若为回文串，则要返回的结果+1，最后返回所要求的结果，神奇的事居然能过，虽然时间和消耗内存都很大。

class Solution {
public:
    // 函数isreverse用于判断字符串s中从索引begin到end的子串是否为回文
    bool isreverse(string s, int begin, int end){
        // 当begin小于等于end时，进行循环
        while(begin <= end){
            // 如果在begin和end位置的字符不相等，则返回false，表示不是回文
            if(s[begin] != s[end]){
                return false;
            }
            // 将begin索引向前移动，将end索引向后移动
            begin++;
            end--;
        }
        // 如果循环完成，所有字符都相等，返回true，表示是回文
        return true;
    }
    int countSubstrings(string s) {
        // 初始化结果变量result为0
        int result = 0;
        // 外层循环遍历字符串s的每个字符作为子串的起始字符
        for(int i = 0; i < s.size(); i++){
            // 内层循环遍历字符串s的每个字符作为子串的结束字符
            for(int j = i; j < s.size(); j++){
                // 如果从i到j的子串是回文，则将result加1
                if(isreverse(s, i, j))
                    result++;
            }
        }
        // 返回计算出的回文子串数量
        return result;
    }
};

算法的时间复杂度为O(n^3)，空间复杂度为O(1)。

中心扩展（双指针）

回文子串可以从它的中心向外扩展得到，而中心可能事一个字符（奇数长度的回文）或两个相邻字符（偶数长度的回文）。

class Solution {
public:
    // 函数countSubstrings用于计算字符串s中回文子串的数量
    int countSubstrings(string s) {
        // 初始化结果变量result为0
        int result = 0;
        // 遍历所有可能的中心点，中心点可能是一个字符（奇数长度的回文）或两个相邻字符（偶数长度的回文）
        for (int center = 0; center < 2 * s.size() - 1; center++) {
            // 计算当前中心点对应的左边界索引left
            int left = center / 2;
            // 计算当前中心点对应的右边界索引right
            int right = left + center % 2;
            // 当左边界索引大于等于0，右边界索引小于字符串长度，且左右边界对应的字符相同时，进行循环
            while (left >= 0 && right < s.size() && s[left] == s[right]) {
                // 回文子串数量加1
                result++;
                // 将左边界索引向左移动
                left--;
                // 将右边界索引向右移动
                right++;
            }
        }
        // 返回计算出的回文子串数量
        return result;
    }
};

算法的时间复杂度为O(n^2)，空间复杂度为O(1)。

动态规划

代码随想录 (programmercarl.com)

动态规划，字符串性质决定了DP数组的定义 | LeetCode：647.回文子串_哔哩哔哩_bilibili

dp[i][j],i到j的子串是否为回文串，感觉就是中心扩展的思路。

如果s[i] == s[j]，

i == j 回文子串

j-i == 1回文子串

j-i>1，需要判断dp[i+1][j-1]是否为回文子串。

if(s[i]==s[j]){
    if(j-i<=1){
        dp[i][j] = true;
        result++;
    }
    if(j-i>1){
        if(dp[i+1][j-1])
            dp[i][j] = true;
            result++;
    }
}

dp[i][j]的初始化为false。

遍历顺序 从底向上，从左向右，看遍历公式。

最后返回result，dp数组中true的数目

class Solution {
public:
    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;
    }
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n^2)。

最长回文子序列

516. 最长回文子序列 - 力扣（LeetCode）

动态规划一

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

递推关系

若s[i] == s[j]，则dp[i][j] = dp[i+1][j-1]+2，考虑回文串前后相等，则长度加2.

若不相等，则同时加入不能形成回文串，则考虑分别加入时是否能形成回文串

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

从递推公式可知，当i、j相同时，递推公式是无效的，对于i、j相同的情况，我们需要手动将dp[i][j] = 1.其他值全部初始为0.

根据递推公式，考虑从左下到右上。

最后返回dp[0][s.size()-1]

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        // 创建二维动态规划数组dp，大小为s.size() x s.size()，初始化为0
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        // 初始化对角线，每个字符自身构成长度为1的回文子序列
        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++) {
                // 如果s的第i个字符和第j个字符相同
                if (s[i] == s[j]) {
                    // dp[i][j]等于dp[i+1][j-1]加2，因为两边的字符可以构成回文
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                } else {
                    // 否则，dp[i][j]等于dp[i+1][j]和dp[i][j-1]中的较大值
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        // 返回dp[0][s.size()-1]，即整个字符串s的最长回文子序列的长度
        return dp[0][s.size() - 1];
    }
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n^2)。

动态规划二

看到leetcode上一个叫Clever hodes的思路，将序列反转之后得到序列2，求两个序列的最长公共子序列就好了。很巧妙的思路，但相比动态规划一复杂度更高。

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        // 创建字符串s的反转s2
        string s2(s);
        reverse(s2.begin(), s2.end());
        // 创建二维动态规划数组dp，大小为(s.size()+1) x (s.size()+1)，初始化为0
        vector<vector<int>> dp(s.size() + 1, vector<int>(s.size() + 1, 0));
        // 遍历字符串s的每个字符
        for (int i = 1; i <= s.size(); i++) {
            // 遍历字符串s2的每个字符
            for (int j = 1; j <= s.size(); j++) {
                // 如果s的第i个字符和s2的第j个字符相同
                if (s[i - 1] == s2[j - 1]) {
                    // dp[i][j]等于dp[i-1][j-1]加1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    // 否则，dp[i][j]等于dp[i-1][j]和dp[i][j-1]中的较大值
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        // 返回dp[s.size()][s.size()]，即最长回文子序列的长度
        return dp[s.size()][s.size()];
    }
};

算法的时间复杂度为O(n^2)，空间复杂度为O((n+1)^2)。