最长回文子串和最长回文子序列

这两个题目我觉得可以放在一起讨论下：

字长回文子序列

首先是回文子序列的题目，涉及到子序列，一般都是不连续的问题：
那么首推动态规划，并且这个题目只要求返回长度，那么dp数组用来存子问题的最长回文串长度就可以，即dp[i][j] 表示，从i -j这段的最长回文子串的长度，
递推公式：

if( s.charAt(i) == s.charAt(j))
                   ans[i][j] = ans[i + 1][j - 1] + 2;
               else
               {
                   ans[i][j] = Math.max(ans[i+1][j] , ans[i][j -1]);
               }

即相等时，在中间段的长度加2，不相等则返回减去头或者减去尾的长度。
总体代码如下：

class Solution {
    public int longestPalindromeSubseq(String s) {
   int n = s.length();
       int [][] ans =new int[n][n];
       for( int i = 0 ; i < n ; i++)
           for( int j = 0 ; j < n  ; j++)
               if( i == j)
                   ans[i][j] = 1;
               else
                   ans[i][j] = 0;
       for (int i = n -2 ; i >=0 ;i--)
           for ( int j = i+1 ; j <n ;j++)
           {
               if( s.charAt(i) == s.charAt(j))
                   ans[i][j] = ans[i + 1][j - 1] + 2;
               else
               {
                   ans[i][j] = Math.max(ans[i+1][j] , ans[i][j -1]);
               }
           }
       return ans[0][n -1];
    }
}

也可以再造一个辅助字符串，s2，这个问题转化为，求s1和s2的最长公共子序列的问题。

最长回文子串

子串问题，那么和前面子序列的想法差不多，假设去掉头和尾后中间一段为回文，那么如果头和尾相等，那么这个串也是回文的。
中间段为一个字符时候，则中间段定为回文的，所以递推公式也就出来了：

if((dp[l + 1][r - 1] || r - l <= 2) && s.charAt(l) == s.charAt(r))

并且这个需要返回最长的回文子串，所以需要记录最长回文子串的位置：
总体代码如下：

class Solution {
    public String longestPalindrome(String s) {
      int n = s.length();
        if(n < 2)
            return s;
        boolean[][] dp = new boolean[n][n];
        int max_s = 0 , max_e = 0;
        int max_len =1;
        for(int r = 1 ; r < n ; r++)
        {
            for(int l = 0 ; l < r ; l++)
            {
                 if((dp[l + 1][r - 1] || r - l <= 2) && s.charAt(l) == s.charAt(r))
                {
                    dp[l][r] = true;
                    if(r - l + 1 > max_len)
                    {
                        max_len = r - l + 1;
                        max_e = r;
                        max_s = l;
                    }
                }
            }
        }
        return s.substring(max_s,max_e +1);
    }
}