辛星Java动态规划教程第二篇:最长公共子序列(LCS)

最长公共子序列，即Longest Common Subsequence，通常简称为LCS。
假如我们有两个子序列，比如{a,b,c,d,e,f}和{a,c,e,f,d}，这里的最长公共子序列就是{a,c,e,f}。
当然需要说明的是，最长公共子序列可能不止一个。
常规的思路有两个:
(1).使用一个二维数组来存储序列M和序列N的各自的位数的对应的最大长度，并且寻找一个递推关系，此时时间复杂度为O(m*n)。
(2).转换为递增子序列问题，这个过程会稍微复杂一些，我们在后面再介绍。

我们先介绍第一个思路，它的思路就是用一个二维数组来保存两个序列的各自的对应的位数时的最大长度，这里我们重点是找出这个递推公式。
如果序列M的第i位和序列N的第j位相同的话，那么arr[m][n] = arr[m-1][n-1]+1.
如果不同的话，arr[m][n]的值就是arr[m-1][n]和arr[m][n-1]的最大值。
有了这个递推关系，我们就很好写代码了。这里需要说明的是，在我们输出这个序列的时候，我们可以存储在一个栈中，然后依次向前寻找。

虽然我们这里是通过把公共子串保存在一个栈中的，但是也可以不用额外的存储，直接从低到高进行比对即可，不过此时考虑的不是降序，而是如何去升序。

我们来看一下具体的代码吧：

package com.mengzhidu.teach.algorithm.dp.demo.line;

import java.util.Stack;

/**
 * 最长公共子序列
 * 这里是子序列，不要求内容是连续的，但是有顺序要求
 */
public class LcsDemo1 {

    public static void main(String[] args) {
        String a = "acdefc";
        String b = "abcc";
        lcs(a, b);
    }

    private static void lcs(String a, String b) {
        char[] aChar = a.toCharArray();
        char[] bChar = b.toCharArray();
        int[][] arr = new int[aChar.length + 1][bChar.length + 1];

        for (int i = 1; i < aChar.length + 1; i ++) {
            for (int j = 1; j < bChar.length + 1; j++) {
                if (aChar[i-1] == bChar[j-1]) {
                    arr[i][j] = arr[i-1][j-1]  + 1;
                } else {
                    arr[i][j] = arr[i-1][j] > arr[i][j-1] ? arr[i-1][j] : arr[i][j-1];
                }
            }
        }

        int length = arr[aChar.length][bChar.length];
        System.out.println("长度为:" + length);

        Stack s = new Stack();
        int m = aChar.length - 1;
        int n = bChar.length - 1;
        while (m >= 0 && n >= 0) {
            if (aChar[m] == bChar[n]) {
                s.push(aChar[m]);
                m --;
                n --;
            } else {
                if (arr[m][n+1] > arr[m+1][n]) {
                    m--;
                } else {
                    n--;
                }
            }
        }
        System.out.println("下面输出最长子序列:");
        while (!s.isEmpty()) {
            System.out.print(s.pop() + " ");
        }
    }
}

对于最长公共子序列，我们就介绍到这里啦。