最长回文子串

最新推荐文章于 2024-07-20 22:34:59 发布

坚强果

最新推荐文章于 2024-07-20 22:34:59 发布

阅读量85

点赞数 1

分类专栏： Java | 数据结构文章标签： leetcode 算法 java 数据结构

本文链接：https://blog.csdn.net/weixin_64739098/article/details/128229255

版权

Java | 数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、题目描述

二、我的解题（暴力且弱智）

没错今天又是猪脑过载的一天，看到这个题目我马上就有了一个弱智思路

class Solution {
    public String longestPalindrome(String s) {
        if(s.length()<=1){
            return s;
        }
        String s1="";
        for (int i=0;i<s.length();i++){
            for (int j=i+1;j<s.length();j++){
                if (s.charAt(i)==s.charAt(j)){
                    for (int k=0;k<(j-i+1)/2;k++){
                        System.out.println(i+","+j+"  s.charAt(i+k)"+s.charAt(i+k)+" ,s.charAt(j-k)"+s.charAt(j-k));
                        if(s.charAt(i+k)!=s.charAt(j-k)){
                            break;
                        }else{
                            if (k==(j-i+1)/2-1){
                                if (s1.length()<s.substring(i,j+1).length()){
                                    s1=s.substring(i,j+1);
                                }
                            }
                        }
                    }
                }
            }
        }
        if(s1.length()==0){
            s1= String.valueOf(s.charAt(0));
        }
        return s1;
    }
}

这种傻逼解法也只有我能写出来了，理论上是没有任何问题，牺牲了极大的代价，需要很长的运行时间，经过测试，发现果然过不了审。。。。。。

三、改进

class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 2) {
            return s;
        }
        int strLen = s.length();
        int maxStart = 0;  //最长回文串的起点
        int maxEnd = 0;    //最长回文串的终点
        int maxLen = 1;  //最长回文串的长度

        boolean[][] dp = new boolean[strLen][strLen];

        for (int r = 1; r < strLen; r++) {
            for (int l = 0; l < r; l++) {
                if (s.charAt(l) == s.charAt(r) && (r - l <= 2 || dp[l + 1][r - 1])) {
                    dp[l][r] = true;
                    if (r - l + 1 > maxLen) {
                        maxLen = r - l + 1;
                        maxStart = l;
                        maxEnd = r;

                    }
                }
            }
        }
        return s.substring(maxStart, maxEnd + 1);
    }
}
这个解法的时间和空间复杂度都不是最优的，但是他的代码及其精简。这个方法称为中心扩散法。
起初 left=right=下标 ，就是说找左右不相等且与自身的，如果左边相等就left--,右边同理
比如"abcd"，左右都不相等，所以他的回文子串是任一个
比如"abacd"，b的左右相等，然后left--,right--, 后不相等了，返回aba
比如"abbcd"，b的右边相等，然后,right--, 后不相等了，返回bb

所以返回 s.substring( left , right + 1);
s.substring( 1 , 7)=bcddcb