经典算法题06-最长子序列

一：作用

最长公共子序列的问题常用于解决字符串的相似度，是一个非常实用的算法，是基本功。

二：概念

举个例子，cnblogs这个字符串中子序列有多少个呢？很显然有27个，比如其中的cb,cgs等等都是其子序列，我们可以看出子序列不见得一定是连续的，连续的那是子串。

我想大家已经了解了子序列的概念，那现在可以延伸到两个字符串了，那么大家能够看出：cnblogs和belong的公共子序列吗？

在你找出的公共子序列中，你能找出最长的公共子序列吗？

从图中我们看到了最长公共子序列为blog，仔细想想我们可以发现其实最长公共子序列的个数不是唯一的，可能会有两个以上，但是长度一定是唯一的，比如这里的最长公共子序列的长度为4。

三：解决方案

<1> 枚举法

这种方法是最简单，也是最容易想到的，当然时间复杂度也是龟速的，我们可以分析一下，刚才也说过了cnblogs的子序列个数有27个 ，延伸一下：一个长度为N的字符串，其子序列有2N个，每个子序列要在第二个长度为N的字符串中去匹配，匹配一次需要O(N)的时间，总共也就是O(N*2N)，可以看出，时间复杂度为指数级，恐怖的令人窒息。

<2> 动态规划

既然是经典的题目肯定是有优化空间的，并且解题方式是有固定流程的，这里我们采用的是矩阵实现，也就是二维数组。

第一步：先计算最长公共子序列的长度。

第二步：根据长度，然后通过回溯求出最长公共子序列。

现有两个序列X={x1,x2,x3，...xi}，Y={y1,y2,y3，....，yi}，

设一个C[i,j]: 保存Xi与Yj的LCS的长度。


递推方程为：

不知道大家看懂了没？动态规划的一个重要性质特点就是解决“子问题重叠”的场景，可以有效的避免重复计算，根据上面的公式其实可以发现C[i,j]一直保存着当前(Xi,Yi)的最大子序列长度。

图大家可以自己画一画。例如：我输入两个序列X=acgbfhk，Y=cegefkh。

四：编码

cnblogs和belong的公共子序列的代码完全是根据上面的公式照搬过来：

/** * Created by xuming on 2016/6/14. */
public class LongestSonSeq {
    static int[][] martix;

    static String str1 = "cnblogs";
    static String str2 = "belong";

    public static void main(String[] arge) {
        martix = new int[str1.length() + 1][str2.length() + 1];
        LCS(str1, str2);
        //只要拿出矩阵最后一个位置的数字即可
        System.out.println("当前最大公共子序列的长度为:" + martix[str1.length()][str2.length()]);
    }

    static void LCS(String str1, String str2) {
        //初始化边界，过滤掉0的情况
        for (int i = 0; i <= str1.length(); i++)
            martix[i][0] = 0;

        for (int j = 0; j <= str2.length(); j++)
            martix[0][j] = 0;

        //填充矩阵
        for (int i = 1; i <= str1.length(); i++) {
            for (int j = 1; j <= str2.length(); j++) {
                //相等的情况
                char[] strchar1 = str1.toCharArray();
                char[] strchar2 = str2.toCharArray();
                if (strchar1[i - 1] == strchar2[j - 1]) {
                    martix[i][j] = martix[i - 1][j - 1] + 1;
                    System.out.println("martix[i][j]:" + String.valueOf(strchar1[i - 1]) + " i:" + i + ";j:" + j);
                } else {
                    //比较“左边”和“上边“，根据其max来填充
                    if (martix[i - 1][j] >= martix[i][j - 1]) {
                        martix[i][j] = martix[i - 1][j];
                    } else {
                        martix[i][j] = martix[i][j - 1];
                    }
                }
            }
        }
    }
}

时间复杂度：构建矩阵花费O(MN)的时间，回溯时花费了O（M+N)的时间，两者相加最终花费了O(MN)的时间。

空间复杂度：构建矩阵花费O(MN)的空间，标记函数也花费了O(MN)的空间，两者相加最终花费了O(MN)的空间。