leetcode经典题目:最长回文子串

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

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

中心扩展算法:
比较容易理解,就是对该字符串的每个中心进行遍历,对每个中心往外扩展,判断两边是否相等,每个中心结束后更新最大回文子串;
我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n - 12n−1 个这样的中心。
你可能会问，为什么会是 2n - 12n−1 个，而不是 nn 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（例如 {“abba”}“abba” 的中心在两个{‘b’}‘b’ 之间）。

class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() < 1)
            return "";
        int start = 0; int end = 0;
        for(int i = 0;i < s.length();i++){
            int len1 = expandAroundCenter(s,i,i);
            int len2 = expandAroundCenter(s,i,i+1);
            int len = Math.max(len1,len2);
            if(len > end - start){
                start = i - (len - 1)/2;
                end = i + len/2;
            }
        }
        return s.substring(start,end+1);
    }
    public int expandAroundCenter(String s,int left,int right){
        int r = right; int l = left;
        while(l >= 0 && r < s.length() && s.charAt(r) == s.charAt(l)){
            r++;
            l--;
        }
        return r - l -1;
    }
}

典型解法:动态规划

本人原创的关于动态规划的文章;经典中的经典算法:动态规划(详细解释,从入门到实践,逐步讲解)

1,划分为子问题
该问题最小的,能直接求解的应该是长度1和2的子串
所以我们很自然的将该问题划分为长度递减的子问题
2,确定状态
没什么可说的,如题
3,临界条件
长度为1的肯定为回文串,长度为2的也可以很容易通过一边遍历求解初始化
以后的长度可以根据长度1和2推出来
4,状态转移方程
根据3和题意很容易能写出状态转移方程:

于是可以写出递推解法:

class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() < 2)
            return s;
        
        int maxLength = 0; String longest = null; 
        int length = s.length();
        boolean[][] dp = new boolean[length][length];
        
        //长度为1的子串为回文串
        for(int i = 0;i<s.length();i++){
            dp[i][i] = true;
            maxLength = 1;
            longest = s.substring(i,i+1);
        }
        
        //判断长度为2的子串是否为回文串
        for(int i = 0;i<s.length()-1;i++){
            if(s.charAt(i) == s.charAt(i+1)){
                dp[i][i+1] = true;
                maxLength = 2;
                longest = s.substring(i,i+2);
            }
        }
        
        //判断长度为大于2的子串是否为回文串
        for(int len = 3;len <= s.length();len++){
            for(int i = 0,j;(j=i+len-1) < s.length();i++){
                if(s.charAt(i) == s.charAt(j)){
                    dp[i][j] = dp[i+1][j-1];
                if(dp[i][j] && len > maxLength){
                    maxLength = len;
                    longest = s.substring(i,j+1);
                }
                    }else{
                dp[i][j] = false;
            }
            }
        }
        return longest;
    }
}

至于空间优化和递归求法有兴趣可以尝试,方便可以留下代码,哈哈哈哈哈哈哈哈