LCS-最长公共子序列

最长公共子串（Longest Common Subsequence，LCS），子序列和子串的区别：子串是连续的一段。

蛮力法（对s的每一个子序列，检查是否为t的子序列，s有2^m个子序列，t有2^n个子序列，s长度为m，t长度为n）

时间复杂度为O(2^n * 2^m)。

动态规划法（自顶向下）时间复杂度和空间复杂度都是O(m*n)

（最优子结构的意思是全局最优解包含局部最优解，问题能够分解成子问题解决），一般可用四个步骤来解决：找出最优解的结构；递归定义最优解的值；按自底向上的方式计算最优解的值 ；由计算出的结果构造一个最优解。

首先找最优子结构，

设序列S和T的一个最长公共子序列Z，则：

若 sm=tn，则 zk=sm=tn，且Zk-1是Sm-1和Tn-1的最长公共子序列；

若 sm≠tn且 zk≠sm ，则 Z是 Sm-1和 T的最长公共子序列；

若 sm≠tn且 zk≠tn ，则 Z是 S和 Tn-1的最长公共子序列。

大写表示从前到后的序列。

递归关系为：

若s[m] == t
，则l[m]
=l[m-1][n-1]+1；

若s[m] ！= t
，则l[m]
=max{l[m-1]
, l[m][n-1]}.

f(x)=⎧⎩⎨0c[i−1][j−1]max{c[i-1][j], c[i][j-1]}if i=0 or j=0if i,j>0, and si=tjif i,j>0, and si≠tj

解决这个问题，需要求三个问题：LCS（Sm-1，Tn-1）+1；LCS（Sm-1，T），LCS（S，Tn-1）；max{LCS（Sm-1，T），LCS（S，Tn-1）}。

在计算s和t的最长公共子序列时，需要要计算出s和tn-1以及sm-1和t的最长公共子序列,这两个子问题包含一个公共子问题，即tn-1和sm-1的最长公共子序列。

由递归结构可以看出LCS具有子问题重叠性质。但是计算时间随着长度指数增长，考虑到共有O(m*n)个公共子问题，因此采用自底向上的动态规划来提高效率。

附上代码运行环境为jdk1.8：

import java.util.Stack;

public class LCS {
public static int m, n;
public static char[] s, t;
public static int[][] dp;
public static int[][] b;
public static void main(String[] args) {
// TODO Auto-generated method stub
s = new char[]{'A', 'B','C', 'B', 'D', 'A', 'B'};
t = new char[]{'B', 'D', 'C', 'A', 'B', 'A'};
m = s.length;
n = t.length;
dp = new int[m+1][n+1];
b = new int[m+1][n+1];
System.out.println(dpLength());
lcs();
}
public static int dpLength(){
for(int i = 1; i < m+1; i++){
for(int j = 1; j < n+1; j++){
if(s[i-1] == t[j-1]){
dp[i][j] = dp[i-1][j-1] + 1;
b[i][j] = 0;
}else if(dp[i][j-1] >= dp[i-1][j]){
dp[i][j] = dp[i][j-1];
b[i][j] = 1;
}else{
dp[i][j] = dp[i-1][j];
b[i][j] = 2;
}
}
}
return dp[m]
;
}
public static void lcs(){
Stack<Character> stack = new Stack<Character>();
int i = m, j = n;
while(i > 0 && j > 0){
if(b[i][j] == 0){
i--;
j--;
stack.push(s[i]);
}else if(b[i][j] == 1){
j--;
}else{
i--;
}
}
while(!stack.isEmpty()){
System.out.print(stack.pop() +" ");
}
}
}

可能不止一个最长公共子序列，这时，要想到使用一个数组或者容器来保存，以后再写