[leetcode-5]Longest Palindromic Substring(java)

问题描述：
Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

分析：这道题一个很明显的方法是使用二维DP算法，因为如果i，j为回文，则chars[i] ==chars[j]，且i+1,j-1之间构成回文。

利用公式nums[i][j] = chars[i]==(chars[j] &&(i+1>j-1 || nums[i+1][j-1])) :true:false;

代码如下：448ms

public class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        if(length<=0)
            return "";
        boolean[][] nums = new boolean[length][length];

        int max = 1;
        int start = 0;
        int end  = 1;

        char[] chars = s.toCharArray();

        //step from 2 to length
        for(int step = 1;step < length ;step++){
            for(int i = 0;i<length;i++){
                int j = i+step;
                if(j>=length)
                    break;

                nums[i][j] = (chars[i]==chars[j] && (i+1>=j-1 || nums[i+1][j-1]))?true:false;
                if(nums[i][j] && j-i+1>max){
                    max = j-i+1;
                    start = i;
                    end = j+1;
                }
            }
        }
        return s.substring(start,end);
    }
}

---

还有一种比较明显的方法，就是使用以某个元素为中心，左右扩展，一直延伸到不满足条件为止，其时间复杂度为O(n2)，空间复杂度为O(1)。
注意，这里存在的一个问题是，需要对回文长度为偶数还是奇数进行单独的处理，这里处理的方法就是使用从某一点开始遍历，还是从相邻点开始遍历！
代码如下：316ms

public class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        if(length<=0)
            return "";
        int max = 0;
        String maxstr="";

        for(int i = 0;i<length;i++){
            String s1 = expandString(s,i,i);
            if(s1.length()>max){
                max = s1.length();
                maxstr = s1;
            }
            String s2 = expandString(s,i,i+1);
            if(s2.length()>max){
                max = s2.length();
                maxstr = s2;
            }
        }
        return maxstr;
    }
    private String expandString(String s,int left,int right){
        while(left>=0 && right<s.length()){
            if(s.charAt(left)!=s.charAt(right))
                break;
            left--;right++;
        }
        return s.substring(left+1,right);
    }
}

---

据说，，还有一种O(n)时间复杂度的做法，但是我看了两遍，没看懂意思，读者可以自行查询参考blog