【动态规划】查找最长公共子序列
1.什么是最长公共子序列（lcs）
定义：一个数列S,如果分别是另个或多个已知数列的子序列，且是所有匹配此条件中最长的，则称S是已知数列的最长公共子序列；
需要注意的是：子序列不需要在原序列中占用连续的位置。
ege:
x序列：A B C B D A B
y序列：B D C A B A
他们的最长公共子序列为：B C A B,B D A B,B C B A
那么我们是如何查找出这个公共子序列？
（1）穷举法
一个一个找，容易理解，但是解法很麻烦，所占用的时间复杂度很大，为O(n*2^m)，一般不推荐。
（2）简化：a.查找最长公共子序列的长度
b.找子序列
如：
法1：（递归）
package 查找最长公共子序列;
public class 递归 {
public static int lcs(char[] a, char[] b, int i, int j) {
if (i == 0 || j == 0) {
return 0;
} else if (a[i] == b[j]) {
return lcs(a, b, i - 1, j - 1) + 1;
} else {
return max(lcs(a, b, i - 1, j), lcs(a, b, i, j - 1));
}
}
private static int max(int x, int y) {
if (x > y) {
return y;
} else {
return y;
}
}
public static void main(String[] args) {
String s1 = "ABCBDAB";
String s2 = "BDCABA";
System.out.println(lcs(s1.toCharArray(), s2.toCharArray(), s1.length() - 1, s2.length() - 1));
}
}
这样执行的结果是3，显然不对，原因是在判断的时候第0个元素是空，但是实际上传的数组第0个元素是A，并不是空， 所以返回0有可能会少算，所以需要对两个子序列进行扩张，也就是想办法在两个子序列前面加上0
解决方法：将两个子序列分别变成一个带0号字符的新字符数组。如：
package 查找最长公共子序列;
public class 递归 {
public static int lcs(char[] a, char[] b, int i, int j) {
if (i == 0 || j == 0) {
return 0;
} else if (a[i] == b[j]) {
return lcs(a, b, i - 1, j - 1) + 1;
} else {
return max(lcs(a, b, i - 1, j), lcs(a, b, i, j - 1));
}
}
private static int max(int x, int y) {
if (x > y) {
return x;
} else {
return y;
}
}
public static void main(String[] args) {
String s1 = "ABCBDAB";
char[] c1 = new char[s1.length() + 1];
char[] t1 = s1.toCharArray();
c1[0] = (char)0;
for(int i = 0;i < t1.length;i++) {
c1[i + 1] = t1[i];
}
String s2 = "BDCABA";
char[] c2 = new char[s2.length() + 1];
char[] t2 = s2.toCharArray();
c2[0] = (char)0;
for(int i = 0;i < t2.length;i++) {
c2[i + 1] = t2[i];
}
System.out.println(lcs(c1, c2, c1.length - 1, c2.length - 1));
}
}
这样输出结果就为4.
法2：（备忘录）
package 查找最长公共子序列;
public class 递归 {
public static int lcs(char[] a, char[] b, int i, int j, int[][] bak) {
//如果bak[i][j] != -1,说明不是初值，已经计算过了，直接返回备忘录里面的值
if (bak[i][j] != -1) {
return bak[i][j];
}
/*
* 否则将数值存进备忘录里面
*/
if (i == 0 || j == 0) {
bak[i][j] = 0;
} else if (a[i] == b[j]) {
bak[i][j] = lcs(a, b, i - 1, j - 1, bak) + 1;
} else {
bak[i][j] = max(lcs(a, b, i - 1, j, bak), lcs(a, b, i, j - 1, bak));
}
return bak[i][j];
}
private static int max(int x, int y) {
if (x > y) {
return x;
} else {
return y;
}
}
public static void main(String[] args) {
String s1 = "ABCBDAB";
char[] c1 = new char[s1.length() + 1];
char[] t1 = s1.toCharArray();
c1[0] = (char) 0;
for (int i = 0; i < t1.length; i++) {
c1[i + 1] = t1[i];
}
String s2 = "BDCABA";
char[] c2 = new char[s2.length() + 1];
char[] t2 = s2.toCharArray();
c2[0] = (char) 0;
for (int i = 0; i < t2.length; i++) {
c2[i + 1] = t2[i];
}
int[][] bak = new int[c1.length][c2.length];
//将备忘录里面的值初始化为 -1；
for (int i = 0; i < c1.length; i++) {
for (int j = 0; j < c2.length; j++) {
bak[i][j] = -1;
}
}
System.out.println(lcs(c1, c2, c1.length - 1, c2.length - 1, bak));
}
}
法3：（自底向上）
package 查找最长公共子序列;
import java.util.Scanner;
public class 自底向上 {
public static int lcs(char[] a, char[] b, int i, int j, int[][] bak) {
/*
* i和j 都是索引
*/
for (int ii = 0; ii <= i; ii++) {
for (int jj = 0; jj <= j; jj++) {
if (ii == 0 || jj == 0) {
bak[ii][jj] = 0;
} else if (a[ii] == b[jj]) {
bak[ii][jj] = bak[ii - 1][jj - 1] + 1;// 前面已经计算过了
} else {
bak[ii][jj] = max(bak[ii - 1][jj], bak[ii][jj - 1]);
}
}
}
return bak[i][j];// 返回最大值的位置
}
private static int max(int x, int y) {
if (x > y) {
return x;
} else {
return y;
}
}
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
String s1 = s.nextLine();
char[] c1 = new char[s1.length() + 1];
char[] t1 = s1.toCharArray();
c1[0] = (char) 0;
for (int i = 0; i < t1.length; i++) {
c1[i + 1] = t1[i];
}
String s2 = s.nextLine();
char[] c2 = new char[s2.length() + 1];
char[] t2 = s2.toCharArray();
c2[0] = (char) 0;
for (int i = 0; i < t2.length; i++) {
c2[i + 1] = t2[i];
}
int[][] bak = new int[c1.length][c2.length];
System.out.println(lcs(c1, c2, c1.length - 1, c2.length - 1, bak));
}
}