最长公共子序列(二)

在最长公共子序列(一)里实际上做的是最长公共子串问题，而最长公共子序列实际上子串的字符在原串中是可以不连续的。例如：

str1=”1A2C3D4B56”,str2=”“B2D23CA45B6A
“123456”和”12C4B6”都是最长公共子序列。

1.分析

还是用动态规划去解决，因为这个问题符合DP的两个性质：重叠子问题和最优子结构。使用动态规划表存储子问题的最优解，分析如下：
对于两个长度分别为M和N的字符串$s_1$和$s_2$,首先生成 $M\times N$ 的矩阵 $dp[M][N]$，$dp[i][j]$的含义是$s1[0...i]$ 和$s2[0...j]$的公共子序列的长度。

1.1 初始化

首先初始化第一列和第一行，第一列$dp[M-1][0]$的含义是$s_1[0...M-1]$ 与$s_2[0]$ 的最长公共子序列的长度。根据$dp$矩阵的定义，若$s_1[i]==s_2[0]$ , 则$dp[i][0]=0$， 那么后面的$dp[i+1...M][0]$就都是1了。第一行的情况也与第一列的情况类似，例如，$s_1="abdca"$, $s_1="b2cfd4a"$，经过第一次初始化后第一行为：

$$[0,0,0,0,0,0,1]$$
第一列为： $$[0,1,1,1,1] ^\mathrm {T}$$
对于其他位置的$dp[i][j]$,它有三种可能存在的值，先说前两种：

• 如果$s_1[i]\neq s_2[j]$,那么:

  • $dp[i][j]=dp[i-1][j]$ ,表示$dp[i][j]$ 存储的是$s_1[i-1]$与$s_2[j]$的最长公共子序列；
  • $dp[i][j]=dp[i][j-1]$ ,表示$dp[i][j]$ 存储的是$s_1[i]$与$s_2[j-1]$的最长公共子序列；

• 如果$s_1[i]=s_2[j]$,那么:

  • $dp[i][j]=dp[i-1][j-1]+1$ .

  这三种情况选最大的存储即可。

1.2 求最长公共子序列

初始化后，$dp[M][N]$表示最长公共子序列的长度，通过自底向上的回溯，就可以得到最长序列，具体方法如下：
从右下角开始，向左上、左、右三个方向移动，设$i,j$分别表示此时的行数和列数，用$res$ 存储此时的最长序列。

• 如果$dp[i][j]>max\{dp[i-1][j],dp[i][j-1]\}$,说明之前决策一定是选择了$dp[i][j]=dp[i-1][j-1]+1$ ，则$s_1[i]=s_2[j]$，那么这个字符一定属于最长公共子序列，将该字符存入$res$ 后往左上方移动；

• 若$dp[i][j]=dp[i-1][j]$或者$dp[i][j]=dp[i][j-1]$，说明$dp[i][j]=dp[i-1][j-1]+1$不是必须的决策，分别往上方和左方移动即可。

• 若$dp[i][j]=dp[i-1][j]$同时等于$dp[i][j]=dp[i][j-1]$和$dp[i][j]=dp[i-1][j-1]+1$，向上或者向下都可以。

总结起来，通过$dp$求解本问题，就是还原当时如果求解dp的过程，来自哪个策略就向哪个方向移动。

1.3 实现

public class LCSE {

    public static String lcse(String str1, String str2) {
        if (str1 == null || str2 == null || str1.equals("") || str2.equals("")) {
            return "";
        }
        char[] chs1 = str1.toCharArray();
        char[] chs2 = str2.toCharArray();
        int[][] dp = getdp(chs1, chs2);
        int m = chs1.length - 1;
        int n = chs2.length - 1;
        char[] res = new char[dp[m][n]];
        int index = res.length - 1;
        while (index >= 0) {
            if (n > 0 && dp[m][n] == dp[m][n - 1]) {
                n--;
            } else if (m > 0 && dp[m][n] == dp[m - 1][n]) {
                m--;
            } else {
                res[index--] = chs1[m];
                m--;
                n--;
            }
        }
        return String.valueOf(res);
    }

    public static int[][] getdp(char[] str1, char[] str2) {
        int[][] dp = new int[str1.length][str2.length];
        dp[0][0] = str1[0] == str2[0] ? 1 : 0;
        for (int i = 1; i < str1.length; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], str1[i] == str2[0] ? 1 : 0);
        }
        for (int j = 1; j < str2.length; j++) {
            dp[0][j] = Math.max(dp[0][j - 1], str1[0] == str2[j] ? 1 : 0);
        }
        for (int i = 1; i < str1.length; i++) {
            for (int j = 1; j < str2.length; j++) {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                if (str1[i] == str2[j]) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + 1);
                }
            }
        }
        return dp;
    }
}

1.4 变化

做笔试题碰到了最长回文子序列问题，用这个很好想，就是把原字符串反转后，再求最长公共子序列即可。