leetcode——5.最长回文子串

早上两个小时才写出来，但是运行超时。。。

感觉自己是真的不会算法，应该系统学习一下才对。

代码我先粘在这里，然后慢慢优化：

要加油哦，学算法！！！！！

                                                                      ——2019.9.20

之前的惨不忍睹，已删。

方法一，暴力法，重点就是判断一个字符串是否是回文子串，以及设置两个参数来返回最后结果，

即，只需要记录回文串的起始位置和字符串长度即可。

然后在遍历的时候，只考虑当前字符串长度大于已知的最大长度的情况，代码如下：

class Solution {
    public String longestPalindrome(String s) {
        //暴力解法
        int len = s.length();
        //最后走只需要记录其实下标以及字符串长度即可得到答案
        int begin = 0;
        int strLen = 1;
        if(len < 2){
            return s;
        }//长度为0 和1 的字符串直接输出本身
        for(int i = 0;i<len - 1;i++){
            for(int j = i+1;j<len;j++){
                //判断回文子串的函数
                //判断从起始位置i到终止位置j的字符串是否是回文字符串
                if(j-i+1>strLen && isPalindromic(s,i,j)){
                    begin = i;
                    strLen = j-i+1;
                }
            }
        }
        return s.substring(begin,begin+strLen);
    }

    private boolean isPalindromic(String s, int begin, int end) {
        while(begin < end){
            if(s.charAt(begin) != s.charAt(end)){
                return false;
            }
            begin ++;
            end --;
        }
        return true;
    }
}

 方法二，中心扩展法

class Solution {
    public String longestPalindrome(String s) {//中心扩散法分为奇数中心和偶数中心两种情况，但是可以统一来讨论；
        int len = s.length();
        if(len<2){
            return s;
        }
        int begin = 0;
        int maxLen = 1;  //以上部分与暴力法是想相同的
        for(int i = 0;i<len-1;i++){  //遍历中心位置下标   还需要有一个函数来判断字符串是否是回文子串，从中心向两边扩散的方法
            int oddLen = expandAcountCenter(s,i,i);  //奇数中心位
            int evenLen = expandAcountCenter(s,i,i+1);  //偶数中心位
            if(Math.max(oddLen,evenLen) > maxLen){
                maxLen = Math.max(oddLen,evenLen);
                begin = i - (maxLen -1) / 2;
            }
        }
        return s.substring(begin,begin + maxLen);
    }

    private int expandAcountCenter(String s, int left, int right) {
        int len = s.length();
        while(left >= 0  && right < len){
            if(s.charAt(left) == s.charAt(right)){
                left --;
                right ++;
            }else{
                break;
            }
        }
        return right-left-1;
    }
}

中心扩展法分为奇数偶数的情况。

方法三：动态规划

public String longestPalindrome(String s) {
        //动态规划
        int len = s.length();
        if(len < 2){
            return s;
        }
        int maxLen = 1;
        int begin = 0;
        boolean[][] dp = new boolean[len][len];
        for(int i = 0;i<len;i++){
            dp[i][i] = true;
        }
        for(int j = 1;j<len;j++) {
            for (int i = 0; i < len; i++) {
                if(s.charAt(i) != s.charAt(j)){
                    dp[i][j] = false;
                }else{
                    if(j-i<3){
                        dp[i][j] = true;
                    }else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                }
                if(dp[i][j] && j-i+1 > maxLen){
                    maxLen = j-i+1;
                    begin = i;
                }
            }
        }
        return s.substring(begin,begin + maxLen);
    }

——2020.7.7

---

public String longestPalindrome(String s) {
        int len = s.length();
        if(len == 0) return "";
        char[] c = s.toCharArray();
        String str = "";
        for(int i = 0;i<len;i++){
            String s1 = isPalindrome(c,i,i,len);
            String s2 = isPalindrome(c,i-1,i,len);
            if(s1.length()>str.length()){
                str = s1;
            }
            if(s2.length()>str.length()){
                str = s2;
            }
        }
        return str;
    }

    private String isPalindrome(char[] c,int start,int end,int len){
        if(start<0){
            return String.valueOf(Arrays.copyOfRange(c,0,end));
        }
        if(end>=len){
            return String.valueOf(Arrays.copyOfRange(c,start,end));
        }
        while (start>=0 && end<len) {
            if (c[start] == c[end]) {
                start--;
                end++;
            }else{
                return String.valueOf(Arrays.copyOfRange(c,start+1,end));
            }
        }
        return String.valueOf(Arrays.copyOfRange(c,start+1,end));
    }

 还是我自己最后写的这个方法性能最好一点。

 ——2020.8.31