动态规划-LCS求最长公共子序列的长度

1、题目描述

求两个字符串的最长公共子序列，注意是序列，不是子串，令：
s1 = abcbdab
s2 = bdcabd

2、题目分析

要得到 s1 和 s2 的最长公共子序列，先比较两者的最后一位是否相同：
(1) 如果相同，将最后一位拿掉，作为中间结果保存。然后再比较去除最后一位的两个字符串
(2) 如果不同，去掉其中一个字符串的最后一位再比较，也就是比较 abcbda 和 bdcabd，或者比较 abcbdab 和 bdcab
由此可以得到公式如下：

最长子序列求解公式.png

显然，这个问题存在最优子结构，子问题存在重叠部分，如果采用分治策略，会导致相同的子问题重复计算，严重影响算法性能。所以应该使用动态规划进行求解。
根据两个子串做出如下表格，填充规则为：
(1) 第1行和第1列全部用 0 填充；
(2) 从第二行开始，以坐标 x(i, j) 从左向右移动，如果行列对应的字母相同，则填充 x(i-1, j-1) + 1，否则填充 max(x(i-1, j), x(i, j-1))
(3) 按照 (2) 填充完所有的行
则字符串 s1 和 s2 的最长子序列长度为坐标 x(s1.length, s2.length) 的填充值

图2.1 最长子序列动态规划填充表

3、代码实现

public class LCS {
    public static void main(String[] args) {
        String s1 = "bdcabd";
        String s2 = "abcbdab";
        int[][] lcsTable = getLcsTable(s1, s2);
        String lcs = lcs(s1, s2, lcsTable);
        System.out.println("最长公共子序列为：" + lcs);
    }

    private static int[][] getLcsTable(String s1, String s2) {
        int[][] lcsTable = new int[s1.length() + 1][s2.length() + 1];
        char[] chars1 = s1.toCharArray();
        char[] chars2 = s2.toCharArray();

        // 按照规则开始填表
        for (int i = 0; i <= s1.length(); i++) {
            for (int j = 0; j <= s2.length(); j++) {
                if (i == 0 || j == 0) {
                    lcsTable[i][j] = 0;
                    continue;
                }
                if (chars1[i - 1] == chars2[j - 1]) {
                    lcsTable[i][j] = lcsTable[i - 1][j - 1] + 1;
                } else {
                    lcsTable[i][j] = Math.max(lcsTable[i - 1][j], lcsTable[i][j - 1]);
                }
            }
        }
        // 输出表格
        for (int i = 0; i < lcsTable.length; i++) {
            for (int j = 0; j < lcsTable[0].length; j++) {
                System.out.print(lcsTable[i][j] + " ");
            }
            System.out.println();
        }
        return lcsTable;
    }

    // 根据lcsTable获取最长公共序列
    private static String lcs(String s1, String s2, int[][] lcsTable) {
        Stack stack = new Stack<>();
        int i = s1.length();
        int j = s2.length();
        while (i > 0 && j > 0) {
            if (s1.charAt(i-1) == s2.charAt(j-1)) {
                stack.push(s1.charAt(i-1));
                i--;
                j--;
            } else {
                if (lcsTable[i - 1][j] > lcsTable[i][j - 1]) {
                    i--;
                } else {
                    j--;
                }
            }
        }

        StringBuilder sb = new StringBuilder();
        while (stack.peek() != null) {
            sb.append(stack.pop());
        }
        return sb.toString();
    }
}

4、算法复杂度分析

O(n*m)