题目
LeetCode原题-最长回文子序列
给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。
子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。
示例 1：
输入：s = “bbbab”
输出：4
解释：一个可能的最长回文子序列为 “bbbb” 。
示例 2：
输入：s = “cbbd”
输出：2
解释：一个可能的最长回文子序列为 “bb” 。
换句话说，就是删减完的字符串读出来左右两边是一样的：
如字符串 String s = “as1d2jk3a3jkh2gv1d”，最长回文子序列就是123a321。
这道题解法可参考上篇文章最长公共子序列。
将给定的字符串s进行逆序，生成新的字符串s1，求字符串s和字符串s1的最长公共子序列的长度即为最长回文子序列的长度。
举例： String s = “as1d2jk3a3jkh2gv1d” String s1 = “d1vg2hkj3a3kj2d1sa”。
公共子序列为：123a321，即为所求的最长回文子序列。
代码：
public static int lpsl1(String str) {
if (null == str || str.length() == 0) {
return 0;
}
char[] str1 = str.toCharArray();
char[] str2 = reverse(str1);
return process(str1, str2, str1.length - 1, str2.length - 1);
}
public static char[] reverse(char[] str) {
int N = str.length;
char[] str1 = new char[N];
for (int i = 0; i < str.length; i++) {
str1[i] = str[--N];
}
return str1;
}
public static int process(char[] str1, char[] str2, int i, int j) {
if (i == 0 && j == 0) {
return str1[i] == str2[j] ? 1 : 0;
} else if (i == 0) {
if (str1[i] == str2[j]) {
return 1;
} else {
return process(str1, str2, i, j - 1);
}
} else if (j == 0) {
if (str1[i] == str2[j]) {
return 1;
} else {
return process(str1, str2, i - 1, j);
}
} else {
int p1 = process(str1, str2, i - 1, j);
int p2 = process(str1, str2, i, j - 1);
int p3 = str1[i] == str2[j] ? 1 + process(str1, str2, i - 1, j - 1) : 0;
return Math.max(p3, Math.max(p1, p2));
}
}
刚才的方法是根据公共子序列推演出来的方法，那现在让我们来直面这个问题，同样是采用暴力递归+动态规划的方式来进行解答。
暴力递归
依然是从暴力递归开始，写出暴力递归方法后优化成动态规划。
暴力递归方法主要是返回str[L…R]范围内的最大回文子序列。
共有以下几种情况：
- base case：让L = R时，说明只剩一个字符，每个字符的本身都算是自己的回文子序列，所以return 1。
1.1 如果L = R - 1时，还L 到 R 位置剩两个字符，如果这两个字符相等，说明回文子序列的长度为2，否则每个字符都是自己单独的回文子序列，返回1。
base case考虑完之后，就剩下其余的共4种情况：
- 回文子序列可能不以L位置结尾，但是必须以R位置结尾。
- 回文子序列可能不以R位置结尾，但是必须以L位置结尾。
- 回文子序列即不以L位置结尾，也不以R位置结尾。
- 回文子序列必须以L位置结尾 && 必须以R位置结尾。
根据这几种情况，来写递归方法。
注：下面的递归方法在LC中跑，会因为超时不通过，但是通过给的例子可以发现，不是逻辑性错误，是因为超时。后续将暴力递归优化成动态规划就好了。
代码
public static int lps2(String s) {
if (null == s || s.length() == 0) {
return 0;
}
if (s.length() == 1) {
return 1;
}
char[] str = s.toCharArray();
return process2(str,0,str.length - 1);
}
//递归方法返回 str[L...R]范围内的最大回文子序列
public static int process2(char[] str, int L, int R) {
if (L == R) {
return 1;
} else if (L == R - 1) {
return str[L] == str[R] ? 2 : 1;
} else {
int p1 = process2(str, L + 1, R);
int p2 = process2(str, L, R - 1);
int p3 = process2(str, L + 1, R - 1);
int p4 = str[L] == str[R] ? 2 + process2(str, L + 1, R - 1) : 0;
return Math.max(Math.max(p1,p2),Math.max(p3,p4));
}
}
动态规划
依然是根据上面暴力递归的代码改动态规划，根据代码可发现，可变参数是L 和 R，变化范围是 0 ~ str.lengtth - 1。所以可以确定dp表的大小。
代码
从暴力递归优化成动态规划的第一版代码，代码中有一些小技巧。
比如说根据base case给dp表赋值时，先将dp[N - 1][N - 1]赋值为 -1 （根据base case L = R得知），再用第一个循环将 L = R 和 L = L + 1 赋值。（先赋值dp[N - 1][ N - 1]能够确保不越界）
第二个循 L = N - 3开始 R 从 L + 2开始，是因为第一个循环已经将dp表的最后两行填满了，所以 L 从 N - 3开始填充，R 从 L + 2位置开始。
在根据递归代码可以看出，递归中调用process(L + 1，R ) ，process(L，R - 1) 和 process(L + 1，R - 1)可以看出调用的依赖关系是左、下和左下三个位置。所以整个填充顺序如图所示：
if (null == s || s.length() == 0) {
return 0;
}
if (s.length() == 1) {
return 1;
}
char[] str = s.toCharArray();
int N = str.length;
int[][] dp = new int[N][N];
dp[N - 1][N - 1] = 1;
for (int i = 0; i < N - 1; i++) {
dp[i][i] = 1;
dp[i][i + 1] = str[i] == str[i + 1] ? 2 : 1;
}
for (int L = N - 3; L >= 0; L--) {
for (int R = L + 2; R < N; R++) {
int p1 = dp[L + 1][R];
int p2 = dp[L][R - 1];
int p3 = dp[L + 1][R - 1];
int p4 = str[L] == str[R] ? 2 + dp[L + 1][R - 1] : 0;
dp[L][R] = Math.max(Math.max(p1, p2), Math.max(p3, p4));
}
}
return dp[0][N - 1];
}
再次优化
根据依赖位置（左、下和左下）可以看出，左下的位置是没有必要的，因为求的是最大的回文子序列，左下是（ L + 1, R - 1）的位置，它的范围一定比（L + 1,R） 和 （L , R - 1）小，所以不需要它，那么只需要p1,p2和p4进行比较即可，而p4只有在str[L] == str[R]时，才参与比较，所以还可以进一步优化。
代码
public static int dp2(String s) {
if (null == s || s.length() == 0) {
return 0;
}
if (s.length() == 1) {
return 1;
}
char[] str = s.toCharArray();
int N = str.length;
int[][] dp = new int[N][N];
dp[N - 1][N - 1] = 1;
for (int i = 0; i < N - 1; i++) {
dp[i][i] = 1;
dp[i][i + 1] = str[i] == str[i + 1] ? 2 : 1;
}
for (int L = N - 3; L >= 0; L--) {
for (int R = L + 2; R < N; R++) {
dp[L][R] = Math.max(dp[L + 1][R],dp[L][R - 1]);
if (str[L] == str[R]){
dp[L][R] = Math.max((dp[L][R]),(2 + dp[L + 1][R - 1]));
}
}
}
return dp[0][N - 1];
}
![[36c3 2019]includer](https://img-blog.csdnimg.cn/img_convert/3fadcfd14189c6dc2182b96b0926997f.png)
