【Leetcode】5. 寻找两个正序数组的中位数

题目

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：

输入: "cbbd"
输出: "bb"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解法

方法1

暴力解法，大体意思是判断每一个子串是不是回文串，如果子串是回文串，且长度比较大，则更新最大长度。遍历所有子串的复杂度为O(N^2)，判断是不是回文的时间复杂度为O(N)，总时间复杂度为O(N^2)。

class Solution {
    public String longestPalindrome(String s) {
        int maxLength = 1;
        int begin = 0;
        if(s.length() < 2){
            return s;
        }
        for(int i = 0; i < s.length() - 1; i++){
            for(int j = 1; j < s.length(); j++){
                if(this.isPalindrome(s, i, j)){
                    if(maxLength < j - i + 1){
                        maxLength = j -i + 1;
                        begin = i;
                    }
                }
            }
        }

        return s.substring(begin, begin + maxLength);

    }


    public boolean isPalindrome(String s, int left, int right){
        while(left < right){
            if(s.charAt(left++) != s.charAt(right--)){
                return false;
            }
        }
        return true;
    }
}

在Leetcode的执行结果为超时。

方法2

方法1是先定义左右边界，还可以使用中间扩展的方法，先找到中间位置，然后向两边扩展。从左右边界扩展的算法为O(2n)，判断是否是回文为O(N)，总时间复杂度为O(N^2)

class Solution {
    public String longestPalindrome(String s) {
        int maxLength = 1;
        int begin = 0;
        if(s.length() < 2){
            return s;
        }
        for(int i = 0; i < s.length() - 1; i++){
            int tmp = isPalindrome(s, i, i);
            if (tmp > maxLength){
                maxLength = tmp;
                begin = i - (maxLength-1) / 2;
            }

            tmp = isPalindrome(s, i, i+1);
            if (tmp > maxLength){
                maxLength = tmp;
                begin = i - (maxLength-1) / 2;
            }
        }
        return s.substring(begin, begin + maxLength);

    }


    public int isPalindrome(String s, int left, int right){
        while(left >= 0 && right < s.length()){
            if(s.charAt(left) != s.charAt(right)){
                return right - left - 1;
            }
            left--;
            right++;
        }
        return right - left - 1;
    }
}

方法3

可以使用动态规划解决此问题，定义dp[i,j]定义了从i（包含）到j（包含）这个子串是否为回文串。所以有状态转移方程

dp[i,j] = dp[i+1, j-1] && s.charAt(i) == s.charAt(j)。因为i和j都需要循环一周，所以时间复杂度为O(n^2)。空间复杂度为O(N^2)

class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        if(length < 2){
            return s;
        }
        int begin  = 0;
        int maxLength = 1;
        boolean dp[][] = new boolean[length][length];
        for(int j = 1; j < length; j++){
            for(int i = 0; i < j; i++ ){
                if(s.charAt(i) != s.charAt(j)){
                    dp[i][j] = false;
                }else{
                    if(j - i >= 3){
                        dp[i][j] = dp[i+1][j-1];
                    }else{
                        dp[i][j] = true;
                    }
                    
                    if(dp[i][j] == true && j - i + 1 > maxLength){
                        maxLength = j - i + 1;
                        begin = i;
                    }
                }
            }
        }

        return s.substring(begin, begin + maxLength);
    }
}