LeetCode_5 Longest Palindromic Substring

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/a8341025123/article/details/55806052

题目

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

这是一个最长回文子序列的问题，有以下几种解法

1.动态规划

我在做题时是用这种解法，时间复杂度为o(n^2)。式子不难列出：dp[i][j] = s[i]==s[j] && dp[i+1][j-1]，其中dp[i][j]是布尔型，表示从索引i到j的子串是一个回文数。

在编码时要注意的点：

⑴初始化：s[i][i]必然为true

⑵求解dp[i][j]，需要用到dp[i+1][j-1]，在二维数组表格上dp[i+1][j-1]在dp[i][j]左下角，所以还要初始化dp[i+1][j]为true。编码时要注意循环顺序，以对角线的方式遍历，如下图所示。

⑶java的substring截取字符串是左闭右开:string.substring[left, right)

代码：

public class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        int left=0,right=0;
        boolean[][] dp = new boolean[length][length];
        for(int i=1;i<length;i++) {
            dp[i][i] = true;
            dp[i][i-1] = true;
        }
        dp[0][0] = true;
        //注意遍历顺序
        for(int k=1;k<length;k++) {
            for(int i=0;i<length-k;i++) {
                if( (s.charAt(i) ==s.charAt(i+k)) && dp[i+1][i+k-1] ) {
                    dp[i][i+k] = true;
                    left=i;
                    right=i+k;
                }
            }
        }
        return s.substring(left, right+1);
    }
}

---

2.以某个元素为中心，分别计算偶数长度的回文最大长度和奇数长度的回文最大长度。时间复杂度n^2，空间复杂度1

例如abcbd,可以分别以a、b、c、b、d为中心计算回文串，这样可以计算出奇数长度的回文子序列，但无法计算出偶数长度的回文串

偶数长度回文串：例如abccbd中的bccb，可以分别以ab、bc、cb、bd计算回文子序列

class Solution {
public:
    string longestPalindrome(string s) {
        const int len = s.size();
        if(len <= 1)return s;
        int start, maxLen = 0;
        for(int i = 1; i < len; i++)
        {
            //寻找以i-1,i为中点偶数长度的回文
            int low = i-1, high = i;
            while(low >= 0 && high < len && s[low] == s[high])
            {
                low--;
                high++;
            }
            if(high - low - 1 > maxLen)
            {
                maxLen = high - low -1;
                start = low + 1;
            }

            //寻找以i为中心的奇数长度的回文
            low = i- 1; high = i + 1;
            while(low >= 0 && high < len && s[low] == s[high])
            {
                low--;
                high++;
            }
            if(high - low - 1 > maxLen)
            {
                maxLen = high - low -1;
                start = low + 1;
            }
        }
        return s.substr(start, maxLen);
    }
};

3.