L2-008 最长对称子串/【力扣5】 最长回文子串

题目1

题目来源(pta)：https://pintia.cn/problem-sets/994805046380707840/problems/994805067704549376

对给定的字符串，本题要求你输出最长对称子串的长度。例如，给定Is PAT&TAP symmetric?，最长对称子串为s PAT&TAP s，于是你应该输出11。

输入格式：

输入在一行中给出长度不超过1000的非空字符串。

输出格式：

在一行中输出最长对称子串的长度。

输入样例：

Is PAT&TAP symmetric?

输出样例：

11

题目2

题目来源(力扣)：https://leetcode.cn/problems/longest-palindromic-substring/
给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

示例 2：

输入：s = “cbbd”
输出：“bb”

解法一：暴力解法

枚举所有长度大于1的子串

//判断s是否是回文 
bool isHui(string &s,int left,int right)
{
    while(left<right){
        if(s[left]!=s[right])return false;
        left++;
        right--;
    }
    return true;
}

//暴力法 
string longestPalindrome(string s) {
    int len=s.length();
    if(len<2)return s;
    for(int i=0;i<len;++i){
        for(int j=i+1;j<len;++j){
        	//跳过比已知回文子串的长度短的，maxl记录已知最长回文子串长度，start记录子串起始下标 
            if(j-i+1>maxl&&isHui(s,i,j)){
                maxl=j-i+1;
                start=i;
            }
        }
    }
    return s.substr(start,maxl);
}
int main()
{
    string s;
    getline(cin,s);
    //特判长度
    if(s.length()<2){ 
        cout<<s.length()<<endl;
        return 0;
    }
    //注意可能存在长度为2且不为对称串的情况，ans初始为0测试点4会过不去
    int ans=1;
    for(int i=0;i<s.length();++i){
        for(int j=i+1;j<s.length();++j){
            if(j-i+1>ans&&isHui(s,i,j))ans=j-i+1;
        }
    }
    cout<<ans<<endl;
    return 0;
}

时间复杂度：双重循环+判断是否回文，达到O(n³)
空间复杂度：O(1)

解法二：动态规划

回文字符串具有状态转移性质：一个长度严格大于 2 的回文去掉头尾字符以后，剩下的部分依然是回文。反之，如果一个字符串头尾两个字符都不相等，那么这个字符串一定不是回文。

第 1 步：定义状态

数组dp中dp[i][j] 表示：子串 s[i…j] 是否为回文子串，这里子串 s[i…j] 定义为左闭右闭区间，即可以取到 s[i] 和 s[j]。

第 2 步：状态转移方程

根据头尾字符是否相等，需要分类讨论：

dp[i][j] = (s[i] == s[j]) and dp[i + 1][j - 1]

说明：当子串 s[i..j]的长度等于 2 或者等于 3 的时候，s[i..j] 是否是回文由 s[i] 与 s[j] 是否相等决定。

第 3 步：考虑初始化

单个字符一定是回文串，因此把对角线先初始化为 true，即 dp[i][i] = true。当 s[i…j] 的长度为 2 时，只需要判断 s[i] 是否等于 s[j]，所以二维表格对角线上的数值不会被参考。因此不设置 dp[i][i] = true 也能得到正确结论。

第 4 步：保存结果

一旦得到 dp[i][j] = true，就记录子串的长度和起始位置。

string longestPalindrome(string s) {
        int n = s.size();
        if (n < 2) {
            return s;
        }

        int maxLen = 1;
        int begin = 0;
        // dp[i][j] 表示 s[i..j] 是否是回文串
        vector<vector<int>> dp(n, vector<int>(n));
        // 初始化：所有长度为 1 的子串都是回文串
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        // 递推开始
        // 先枚举子串长度
        for (int L = 2; L <= n; L++) {
            // 枚举左边界，左边界的上限设置可以宽松一些
            for (int i = 0; i < n; i++) {
                // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                int j = L + i - 1;
                // 如果右边界越界，就可以退出当前循环
                if (j >= n) {
                    break;
                }

                if (s[i] != s[j]) {
                    dp[i][j] = false;
                } else {
                    if (j - i < 3) {
                        dp[i][j] = true;
                    } else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }

                // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                if (dp[i][j] && j - i + 1 > maxLen) {
                    maxLen = j - i + 1;
                    begin = i;
                }
            }
        }
        return s.substr(begin, maxLen);
    }

解法三：中心扩散法

「暴力法」和「动态规划」枚举了字符串的左右边界，我们还可以 枚举可能出现的回文子串的「中心位置」，从「中心位置」尝试尽可能向两边，得到回文串。

基本思想

遍历每一个下标，以这个下标为中心，利用「回文串」中心对称的特点，往两边扩散，看最多能扩散多远。

枚举「中心位置」时间复杂度为 O(N)，从「中心位置」扩散得到「回文子串」的时间复杂度为 O(N)，因此时间复杂度可以降到 O(N²)。

细节：回文串在长度为奇数和偶数的时候，「回文中心」的形态不一样：

奇数回文串的「中心」是一个具体的字符，例如：回文串 "aba" 的中心是字符 “b”；
偶数回文串的「中心」是位于中间的两个字符的「空隙」，例如：回文串"abba"的中心是两个 “b”，也可以看成两个 “b” 中间的空隙。

class Solution {
public:
    string longestPalindrome(string s) {
        int len=s.size();
        if(len==0||len==1)
            return s;
        int start=0;//记录回文子串起始位置
        int end=0;//记录回文子串终止位置
        int mlen=0;//记录最大回文子串的长度
        for(int i=0;i<len;i++)
        {
            int len1=expendaroundcenter(s,i,i);//一个元素为中心
            int len2=expendaroundcenter(s,i,i+1);//两个元素为中心
            mlen=max(max(len1,len2),mlen);
            if(mlen>end-start+1)
            {
                start=i-(mlen-1)/2;
                end=i+mlen/2;
            }
        }
        return s.substr(start,mlen);
        //该函数的意思是获取从start开始长度为mlen长度的字符串
    }
private:
    int expendaroundcenter(string s,int left,int right)
    //计算以left和right为中心的回文串长度
    {
        int L=left;
        int R=right;
        while(L>=0 && R<s.length() && s[R]==s[L])
        {
            L--;
            R++;
        }
        return R-L-1;
    }
};