每天写一道算法题（5）-最长回文子串

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

示例 1：

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

输入: "cbbd"
输出: "bb"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

这道题呢，一看没思路，再看还是没思路，能想到的方法只有暴力，不得已去看了题解。

有以下几个方法嘛：

1. 暴力  N3的复杂度
2. 动态规划 复杂度N2
3. 中心扩展法  时间复杂度同动态规划O（N2），但是空间复杂度是O（1）

4. Manacher 算法 复杂度O(N)，也是最复杂的算法；记本45分钟以内难以写不出来，就留到以后再研究了

先说下我的第一个思路，以i为起点j为终点的字符串，如果是回文串需要满足两个条件

1. dp[i] == dp[j]
2. dp[i+1][j-1]是回文串

所以呢，就有了以下代码

if(s.isEmpty())
            return s;
        
        for(i=0;i<len;i++)
            dp[i][i] = 1;
        
        for(i = 0;i < len; i++){
            for(j=i+1; j<len; j++){
                if( s.charAt(i) == s.charAt(j) ){
                    
                    if(j == i+1)
                        dp[i][j] = 2;
                    if(j > i + 1){
                        if(dp[i+1][j-1] != 0)
                        dp[i][j] = j - i + 1;
                    }
                    
                }
                
                if(dp[i][j] > max_len){
                    max_len = dp[i][j];
                    start = i;
                    end = j;
                }
            }
        }
        
        return s.substring(start, end+1);

如果i和j相邻，那么就没有i++和j--，这就是个回文串，如果i和j不相邻的话才有dp[i][j] = j - i +1;

这里dp[][]的作用只是用来判断是不是回文串而且。

 

但是这个程序没A过，程序是有问题的，问题出在判断 dp[i+1][j - 1] != 0,这条语句上面，在逻辑上dp[i+1][j - 1]确实是dp[i][j]的子状态，但是在程序实现里面呢，循环是从for(;i<len;i++)开始的i从小到大递增，当前状态是不可能会有dp[i+1]的状态的。

这个也是刚开始动态规划的时候，背包问题里面，会有一个for(;j>=0;j--)这种从大到小问题循环方式。对于递增循环dp[i+1]这种形式是不同的，同理对于递减循环dp[i-1]也不行，这里把状态传递给疏忽了，再次提醒自己。

 

所以就有了以下代码：

class Solution {
    public String longestPalindrome(String s) {
        int len = s.length();
        int[][]  dp = new int[len][len];
        int i,j;
        int max_len = 0;
        int start = 0, end = 0;
        String str = new StringBuffer(s).reverse().toString();
        
        if(s.isEmpty())
        	return s;
        
        for(i = 0;i < len; i++){
            for(j =0; j < len ; j++){
                if( s.charAt(i) == str.charAt(j) ){
                    if(i ==0 || j==0)
                    {
                        dp[i][j] = 1;
                    }
                    else
                        dp[i][j] = dp[i-1][j-1] + 1;
                    
                }
                
                if(dp[i][j] > max_len){
                    max_len = dp[i][j];
                    start = i;
                    end = j;
                }
            }
        }
        
        return s.substring(start , start + max_len);
    }
}

注意，在这个字符串里面为了避免上面出现的状态传递问题，是先把字符串逆序了的。一个正序一个逆序状态传递就不是很直观。

先这样，等什么时候闲了，再来分析状态和方法三