求最长回文子串——C++ (动态规划+暴力解法)

声明：本文原题主要来自力扣，记录此博客主要是为自己学习总结，不做任何商业等活动！

一、题目描述

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：

输入：s = "cbbd"
输出："bb"
示例 3：

输入：s = "a"
输出："a"
示例 4：

输入：s = "ac"
输出："a"
 

提示：

1 <= s.length <= 1000
s 仅由数字和英文字母（大写和/或小写）组成

二、题目分析

看到该题第一想法是暴力解法，即最长子串的长度从最长到最短开始遍历，假如前面出现回文则直接返回，代码可以参考最后面代码，不过该解法时间复杂度为O(^3)超过时间限制，故考虑动态规划。本题也是采用动态规划才通过啊，下面是具体分析。

2.1动态规划思路分析

1. 状态方程：  f(i, j) = true  表示回文
2. 状态转移方程： f(i, j) = f(i + 1, j - 1); i > 2, 考虑i = 0，i = 1边界
3. 边界条件：   f(i, i) = true; （i < n）
    f(i, i + 1) = (s[i] == s[i + 1]); (i = 1)

    代码实现思路：
    先for循环长度len;
确定遍历左边起点，确定遍历右边终点；（即遍历长度为len的滑动窗口）
记录f(i, j)结果值，即：
if (s[i] != s[j])
f(i, j) = false;
else
if (j - i < 3)
    f(i, j) = true;
else
f(i, j) = f(i + 1, j - 1);

判断回文
if (f(i, j) && j - i + 1 > maxLen)
{
    maxLen = j - i + 1;
    begin = i;
}

循环结束返回s.substr(begin, maxLen);

2.2动态规划代码实现

时间复杂度O(n ^ 2)，空间复杂度O(n ^ 2)

class Solution {        
public:
    string longestPalindrome(string s) {
        int size = s.size();

        if(size < 2)
            return s; 

        int maxLen = 1;
        int begin=0;
        vector<vector<int>> dp(size, vector<int>(size)); // i，j表示字符子串s(i到j)，故可以用二维数组表示
        for(int i=0; i<size;++i) // 所有长度为一的最长子串为true
            dp[i][i]=true;

        for(int subLen=2; subLen<=size; ++subLen) // 子串长度遍历，这里要注意用==
        {
            for(int i=0; i<size; ++i) // 滑动窗口依次右滑
            {
                int j=i+subLen-1;
                if(j>=size) // 滑动窗口右滑终止条件，反之越界
                    break;
                if(s[i]!=s[j])
                    dp[i][j]=false;
                else
                    if(j-i<3) // 此时只能为2，故为true
                        dp[i][j]=true;
                    else
                        dp[i][j]=dp[i+1][j-1]; // 状态转移方程代码实现
                
                if(dp[i][j] && j-i+1>maxLen) // 判断是回文，并且满足最大值才更新maxLen和begin
                {
                    maxLen=j-i+1; // 最大长度
                    begin = i; // 起始位置
                }
            }
        }

        return s.substr(begin, maxLen); // 返回最长子串
    }    
};

2.3结果

 

 2.4暴力解法(超时)

时间复杂度O(n^3)，空间复杂度O(n)

class Solution {    
    string longestPalindrome(string s) {
        if(s.empty())
            return "";
        string tmp(s);
        int size=s.size();
        int subLen=size;
        for(; subLen>0; --subLen)
        {
            for(int i=0; i<=size-subLen; ++i)
            {
                tmp = s.substr(i, subLen);
                if(tmp == string(tmp.rbegin(),tmp.rend()))
                    return tmp;
            }
        }
        return tmp;
    }
};