最长公共子序列

如果简单递归解决最长公共子序列这一问题，时间复杂度为指数级，因为有大量的重复子问题。经研究发现，最长公共子序列满足动态规划算法的条件，所以我们用动态规划解之。
假设字符序列A=“a0，a1，…，am-1”，B=“b0，b1，…，bn-1”，Z=“z0，z1，…，zk-1”为它们的最长公共子序列。
不难证明有以下性质：
（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；
（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；
（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。
这样，在求解序列A和B的公共子序列时: 如有am-1=bn-1，则可将问题归结为解决一个子问题，求解“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。
求解：
我们用一个二维数组c[][]记录公共子序列的中间结果。

初始化以及搜索过程如下表：

程序如下：

    public static int LCS(String s1, String s2)
    {
        if (s1 == null || s1.length() == 0 || s2 == null || s2.length() == 0)
            return 0;
        int len1 = s1.length();
        int len2 = s2.length();

        int[][] res = new int[len1 + 1][len2 + 1];
        for (int i = 0; i <= len1; ++i)
        {
            for (int j = 0; j <= len2; ++j)
            {
                if (i == 0 || j == 0)
                    res[i][j] = 0;
                else if (s1.charAt(i - 1) == s2.charAt(j - 1))
                    res[i][j] = res[i - 1][j - 1] + 1;
                else
                    res[i][j] = max(res[i - 1][j], res[i][j - 1]);
            }
        }
        return res[len1][len2];
    }

    public static int max(int a, int b)
    {
        return a > b ? a : b;
    }