给你一个字符串 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,即为所求的最长回文子序列。
代码:
java
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中跑,会因为超时不通过,但是通过给的例子可以发现,不是逻辑性错误,是因为超时。后续将暴力递归优化成动态规划就好了。
代码
java
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)可以看出调用的依赖关系是左、下和左下三个位置。所以整个填充顺序如图所示:
java
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]时,才参与比较,所以还可以进一步优化。
代码
java
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];
}