蓝桥试题：最长公共子序列（LCS）

一、题目描述

给定一个长度为 N 数组 a 和一个长度为 M 的数组 b。

请你求出它们的最长公共子序列长度为多少。

输入描述

输入第一行包含两个整数 N,M 分别表示数组 a 和 b 的长度。

第二行包含 NN 个整数 a1,a2,...,an​。

第三行包含 MM 个整数 b1,b2,...,bn。

1≤N,M≤1e3，1≤ai,bi≤1e9。

输出描述

输出一行整数表示答案。

输入输出样例

示例 1

输入

5 6
1 2 3 4 5
2 3 2 1 4 5

输出 

4

二、LCS算法 

最长公共子序列（LCS）算法详解及Java实现

最长公共子序列（Longest Common Subsequence，LCS） 是动态规划的经典问题，用于找到两个序列（如字符串、数组）中最长的共同子序列（子序列不要求连续，但顺序需一致）。例如，序列 "ABCBDAB" 和 "BDCAB" 的 LCS 是 "BCAB" 或 "BDAB"，长度为4。

---

算法思路（动态规划）

1. 定义状态

• 设 dp[i][j] 表示序列 X[0..i-1] 和 Y[0..j-1] 的最长公共子序列长度。

• 例如，dp[3][2] 表示 X 的前3个字符与 Y 的前2个字符的LCS长度。

2. 状态转移方程

• 当 X[i-1] == Y[j-1] 时：

  𝑑𝑝[𝑖][𝑗]=𝑑𝑝[𝑖−1][𝑗−1]+1dp[i][j]=dp[i−1][j−1]+1

  当前字符匹配，LCS长度增加1。

• 当 X[i-1] != Y[j-1] 时：

  𝑑𝑝[𝑖][𝑗]=max⁡(𝑑𝑝[𝑖−1][𝑗], 𝑑𝑝[𝑖][𝑗−1])dp[i][j]=max(dp[i−1][j],dp[i][j−1])

  取不包含 X[i-1] 或不包含 Y[j-1] 的较大值。

3. 初始化

• dp[0][j] = 0（空序列与任何序列的LCS长度为0）

• dp[i][0] = 0

4. 结果

• dp[m][n] 即为两个序列的LCS长度，其中 m 和 n 为两序列的长度。

---

Java实现（仅求长度）

public class LCS {
    public static int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length(), n = text2.length();
        int[][] dp = new int[m + 1][n + 1]; // dp数组从空序列开始

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (text1.charAt(i-1) == text2.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
                }
            }
        }
        return dp[m][n];
    }

    public static void main(String[] args) {
        String text1 = "ABCBDAB";
        String text2 = "BDCAB";
        System.out.println(longestCommonSubsequence(text1, text2)); // 输出4
    }
}

三、代码展示

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[] a = new int[n];
        int[] b = new int[m];
        for (int i = 0; i < n ; i++) {
            a[i] = scanner.nextInt();
        }
        for (int i = 0; i < m ; i++) {
            b[i] = scanner.nextInt();
        }
        int max = 0;
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <=  m; j++) {
                if (a[i - 1] == b[j - 1]){dp[i][j] = Math.max(dp[i - 1][j - 1] + 1, dp[i][j]);}
                else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j]);
                    dp[i][j] = Math.max(dp[i][j - 1], dp[i][j]);
                }
                max = Math.max(max , dp[i][j]);
            }
        }
        System.out.println(max);
    }
}