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[n]，则l[m][n]=l[m-1][n-1]+1；
若s[m] ！= t[n]，则l[m][n]=max{l[m-1][n], l[m][n-1]}.

$$f(x)= \begin{cases} 0& \text{if i=0 or j=0}\\ c[i-1][j-1]& \text{if i,j>0, and }s_{i}=t_{j}\\ \text{max{c[i-1][j], c[i][j-1]}}&\text{if i,j>0, and }s_{i} \neq t_{j} \end{cases}$$
解决这个问题，需要求三个问题：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][n];
    }
    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() +" ");
        }
    }
}

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