给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

    子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

    示例 1：

    输入：s = “bbbab”
    输出：4
    解释：一个可能的最长回文子序列为 “bbbb” 。
    示例 2：

    输入：s = “cbbd”
    输出：2
    解释：一个可能的最长回文子序列为 “bb” 。

    提示：

    1 <= s.length <= 1000
    s 仅由小写英文字母组成

    区间dp

    1. class Solution {
    2.     public int longestPalindromeSubseq(String s) {
    3.         int n = s.length();
    4.         char[] cs = s.toCharArray();
    5.         int[][] f = new int[n+10][n+10];
    6.         for (int len = 1; len <= n; ++len) 
    7.             for (int l = 0; len + l - 1 < n; ++l) {
    8.                 int r = len + l - 1;
    9.                 if (len == 1) f[l][r] = 1;
    10.                 else if (len == 2) f[l][r] = cs[l] == cs[r] ? 2 : 1;
    11.                 else {
    12.                     //不选l选r或不选r选l
    13.                     f[l][r] = Math.max(f[l+1][r],f[l][r-1]);
    14.                     //当l == r全选或者不等全不选
    15.                     f[l][r] = Math.max(f[l][r],f[l+1][r-1] + (cs[l] == cs[r] ? 2 : 0));
    16.                 }
    17.             }
    18.         return f[0][n-1];
    19.     }
    20. }

    根据最长回文子序列是与其逆序串的最长公共子序列LCS

    1. class Solution {
    2.     //最长公共子序列
    3.     //f[i,j] 表示所有由第一个序列前i个字母，第二个序列前j个字母的最长公共子序列集合
    4.     //f[i][j] = max(f[i-1][j],f[i][j-1]) 不含a[i]含有b[j]与不含b[j]含有a[i]
    5.     // if (a[i] == b[j]) f[i,j] = max (f[i][j],f[i-1][j-1]+1)
    6.     public int longestPalindromeSubseq(String s) {
    7.         int n = s.length();
    8.         char[] cc = s.toCharArray();
    9.         char[] ss = new char[n];
    10.         for (int i = 0; i < n; ++i) {
    11.             ss[i] = cc[n-i-1];
    12.         }
    13.         int[][] f = new int[n+1][n+1];
    14.         for (int i = 1; i <= n; ++i) 
    15.             for (int j = 1; j <= n; ++j) {
    16.                 f[i][j] = Math.max(f[i-1][j],f[i][j-1]);
    17.                 if (cc[i-1] == ss[j-1]) 
    18.                     f[i][j] = Math.max(f[i][j],f[i-1][j-1]+1);
    19.             }
    20.         return f[n][n];
    21.     }
    22. }