leetcode5

public class Solution {
        private int lo, maxLen;

        public String LongestPalindrome(String s)
        {
            int len = s.Length;
            if (len < 2)
                return s;

            for (int i = 0; i < len - 1; i++)
            {
                extendPalindrome(s, i, i);  //assume odd length, try to extend Palindrome as possible
                extendPalindrome(s, i, i + 1); //assume even length.
            }
            return s.Substring(lo, maxLen);
        }

        private void extendPalindrome(String s, int j, int k)
        {
            while (j >= 0 && k < s.Length && s[j] == s[k])
            {
                j--;
                k++;
            }
            if (maxLen < k - j - 1)
            {
                lo = j + 1;
                maxLen = k - j - 1;
            }
        }
}

https://leetcode.com/problems/longest-palindromic-substring/#/description

 

补充一个python的实现，使用动态规划解决：

class Solution:
    def longestPalindrome(self, s: 'str') -> 'str':
        n = len(s)
        dp = [[False for _ in range(n)]for _ in range(n)]
        count = 0
        res = ''
        for i in range(n):
            dp[i][i] = True
            if count < 1:
                res = s[i]
                count = 1
            
        for i in range(n-1):
            if s[i] == s[i+1]:
                dp[i][i+1] = True
                if count < 2:
                    res = s[i:i+2]
                    count = 2
        
        for k in range(3,n+1):
            for i in range(n-k+1):
                j = i + k - 1
                if s[i] == s[j] and dp[i+1][j-1]:
                    dp[i][j] = True
                    if count < j + 1 - i:
                        count = j + 1 -i
                        res = s[i:j+1]
        return res

java版：

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        boolean[][] dp = new boolean[n][n];
        String ans = "";
        for (int l = 0; l < n; ++l) {
            for (int i = 0; i + l < n; ++i) {
                int j = i + l;
                if (l == 0) {
                    dp[i][j] = true;
                } else if (l == 1) {
                    dp[i][j] = (s.charAt(i) == s.charAt(j));
                } else {
                    dp[i][j] = (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]);
                }
                if (dp[i][j] && l + 1 > ans.length()) {
                    ans = s.substring(i, i + l + 1);
                }
            }
        }
        return ans;
    }
}