最长公共子序列——动态规划

什么是最长公共子序列？

最长公共子序列（LCS）是一个在一个序列集合中（通常为两个序列）用来查找所有序列中最长子序列的问题。一个数列 ，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则称为已知序列的最长公共子序列。最长公共子序列问题是一个经典的计算机科学问题，也是数据比较程序，比如Diff工具，和生物信息学应用的基础。它也被广泛地应用在版本控制，比如Git用来调和文件之间的改变。

 

代码如下：

package com.lzp.util;

import java.util.Scanner;

/**
 * @Author LZP
 * @Date 2021/3/25 19:34
 * @Version 1.0
 *
 * 最大公共子序列
 * 若有多个最大公共子序列，则将所有的情况都打印出来
 */
public class LCS {
    private static int num = 0;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int N = input.nextInt();
        int[] A = new int[N];
        int[] B = new int[N];
        int[][] dp = new int[N + 10][N + 10];
        for (int i = 0; i < N; i++) {
            A[i] = input.nextInt();
        }
        for (int i = 0; i < N; i++) {
            B[i] = input.nextInt();
        }

        // 找到最长公共子序列
        // b数组用于回溯找到最长公共子序列，1代表↖ 2代表↑ 3代表←
        int[][] b = new int[N + 10][N + 10];
        // 时间复杂度O(N^2)
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    // 来源于前一行前一列
                    b[i][j] = 1;
                } else if (dp[i - 1][j] > dp[i][j - 1]){
                    // 查看前面是A数列少一位之后更长，还是B数列少一位之后更长，选较长的那个作为此时的长度
                    dp[i][j] = dp[i - 1][j];
                    // 来源于前一行
                    b[i][j] = 2;
                } else {
                    dp[i][j] = dp[i][j - 1];
                    // 来源于前一列
                    b[i][j] = 3;
                }
            }
        }

        int[] lcs = new int[N];
        LCS(N, N, b, lcs, A);

        for (int i = 0; i < dp[N][N]; i++) {
            System.out.printf("%d ", lcs[i]);
        }
    }

    /**
     * 利用递归求出最长公共子序列
     * 时间复杂度O(n)
     */
    public static void LCS(int i, int j, int[][] b, int[] lcs, int[] A) {
        // 出口
        if (i == 0 || j == 0) {
            return;
        }

        if (b[i][j] == 1) {
            LCS(i - 1, j - 1, b, lcs, A);
            lcs[num++] = A[i - 1];
        } else if (b[i][j] == 2) {
            LCS(i - 1, j, b, lcs, A);
        } else {
            LCS(i, j - 1, b, lcs, A);
        }
    }
}

运行结果：