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)=⎧⎩⎨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][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() +" ");        }    }}

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