蓝桥杯每日一题-最长公共子序列

最新推荐文章于 2023-01-25 18:19:20 发布

hey bro`

最新推荐文章于 2023-01-25 18:19:20 发布

阅读量1.7k

点赞数 9

文章标签：算法蓝桥杯动态规划

本文链接：https://blog.csdn.net/m0_51715325/article/details/121505231

版权

该博客探讨了如何利用动态规划解决字符序列的最长公共子序列（LCS）问题，包括计算长度和个数。文章详细介绍了状态转移方程，并给出了AC代码实现。在原代码基础上进行了滚动数组优化以减少内存消耗，适用于蓝桥杯等竞赛环境。

摘要由CSDN通过智能技术生成

最长公共子序列（求长度以及个数）

蓝桥杯原题链接

题目描述

字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。
令给定的字符序列 X=x0x1…xm−1，序列 Y=y0y1…yk−1 是 X 的子序列，存在 X 的一个严格递增下标序列 <i0,i1,…,ik−1>，使得对所有的 j=0,1,…,k−1，有 xij=yj。
例如，X=ABCBDAB，Y=BCDB 是 X 的一个子序列。
对给定的两个字符序列，求出他们最长的公共子序列长度，以及最长公共子序列个数。

输入格式

第 1 行为第 1 个字符序列，都是大写字母组成，以 . 结束。
第 2 行为第 2 个字符序列，都是大写字母组成，以 . 结束。
注意，两个字符序列均不包含最后的 .。

输出格式

第 1 行输出上述两个最长公共子序列的长度。
第 2 行输出所有可能出现的最长公共子序列个数，答案可能很大，只要将答案对 100,000,000 求余即可。

输入样式

ABCBDAB.
BACBBD.

输出样式

4
7

解题思路

1. 最长公共子序列的长度

本题的第一个输为最长公共子序列的长度，是一个经典dp问题也较为简单
首先定义dp[len1+1][len2+1],其中len1是第一个字符串a的长度，len2是第一个字符串b的长度。
状态表示：
dp[i][j]代表：a的前i个字符与b的前j个字符最长公共子序列的长度。
状态转移
当a[i-1]==b[j-1]
dp[i][j]代表一种状态，这种状态可以由a的前i-1个字符与b的前j-1个字符的最长公共子序列转移而来即dp[i][j]=dp[i-1][j-1]+1
当a[i-1]!=b[j-1]
dp[i][j]可以由a的前i-1个字符与b的前j个字符的最长公共子序列转移而来也可以由a的前i个字符与b的前j-1个字符的最长公共子序列转移而来即dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1])

LCS长度代码

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int len1=text1.length();
        int len2=text2.length();
        int[][] dp=new int[len1+1][len2+1];
        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;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][j-1],dp[i-1][j]);
            }
        }
        return dp[len1][len2];
    }
}

1. 最长子序列的个数
这部分也是本题比较难的地方

定义nums[len1+1][len2+1]数组，nums[i][j]的含义是a的前i个字符与b的前j个字符最长公共子序列的个数，但要对nums数组初始化最左边一列和最上边一行，例如nums[0][2]的含义为a的前0个字符和b的前2个字符的最长公共子序列的个数为1.

状态转移：

若dp[i][j]==dp[i-1][j],说明状态是从dp[i-1][j]转移来的，nums[i][j]要加上nums[i-1][j]
若dp[i][j]==dp[i][j-1],说明状态是从dp[i][j-1]转移来的，nums[i][j]要加上nums[i][j-1]
若a[i]==b[j]且dp[i][j]==dp[i-1][j-1]+1,说明状态是从dp[i-1][j-1]转移来的，nums[i][j]要加上nums[i-1][j-1]
若a[i]!=b[j]且dp[i][j]==dp[i-1][j-1],那么状态nums[i-1][j-1]会多加上一次，所以要让nums[i][j]-=nums[i-1][j-1]
第四点中多加上了一次的原因是：dp[i-1][j]、dp[i][j-1]>=dp[i-1][j-1] (从定义出发去理解) 又因为a[i]!=b[j]所以状态是从dp[i-1][j]、dp[i][j-1]中转移而来，且dp[i][j]==dp[i-1][j-1],所以dp[i-1][j-1]==dp[i-1][j]==dp[i][j-1]，因此dp[i-1][j]与dp[i][j-1]也通过dp[i-1][j-1]转移了状态，一共转移了两次，重复了所以删去。

AC代码

import java.util.*;
import java.io.*;
public class Main {
    static int mod=(int)1e8;
    public static void main(String[] args) throws Exception{
        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
        String a=bf.readLine();
        String b=bf.readLine();
        int len1=a.length(),len2=b.length();
        int[][] dp=new int[len1][len2];
        int[][] nums=new int[len1][len2];
        for(int i=0;i<len1;i++) nums[i][0]=1;//初始化
        for(int i=0;i<len2;i++) nums[0][i]=1;
        for(int i=1;i<len1;i++)
        {
          for(int j=1;j<len2;j++)
          {
            if(a.charAt(i-1)==b.charAt(j-1)){
              dp[i][j]=dp[i-1][j-1]+1;
              nums[i][j]=nums[i-1][j-1];//状态可以从dp[i-1][j-1]转移
            }
            else{
              dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);
              if(dp[i][j]==dp[i-1][j-1])
                nums[i][j]-=nums[i-1][j-1];//减去重复部分
            }
            if(dp[i-1][j]==dp[i][j])
              nums[i][j]+=nums[i-1][j];//状态可以从dp[i-1][j]转移
            if(dp[i][j-1]==dp[i][j])
              nums[i][j]+=nums[i][j-1];//状态可以从dp[i][j-1]转移
            nums[i][j]%=mod;//取余
          }
        }
        System.out.println(dp[len1-1][len2-1]);
        System.out.println(nums[len1-1][len2-1]);
    }
}

上述代码可以通过蓝桥杯的评测，但是洛谷的部分数据会mle,所以改进一下，滚动数组减少内存

import java.util.*;
import java.io.*;
public class Main {
    static int mod=(int)1e8;
    public static void main(String[] args) throws Exception{
        BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
        String a=bf.readLine();
        String b=bf.readLine();
        int len1=a.length(),len2=b.length();
        int[] dp1=new int[len2];
        int[] dp2=new int[len2];
        int[][] nums=new int[len1][len2];
        for(int i=0;i<len1;i++) nums[i][0]=1;//初始化
        for(int i=0;i<len2;i++) nums[0][i]=1;
        for(int i=1;i<len1;i++)
        {
            for(int j=1;j<len2;j++)
            {
                if(a.charAt(i-1)==b.charAt(j-1)){
                    dp2[j]=dp1[j-1]+1;
                    nums[i][j]=nums[i-1][j-1];//状态可以从dp[i-1][j-1]转移
                }
                else{
                    dp2[j]=Math.max(dp1[j],dp2[j-1]);
                    if(dp2[j]==dp1[j-1])
                        nums[i][j]-=nums[i-1][j-1];//减去重复部分
                }
                if(dp1[j]==dp2[j])
                    nums[i][j]+=nums[i-1][j];//状态可以从dp[i-1][j]转移
                if(dp2[j-1]==dp2[j])
                    nums[i][j]+=nums[i][j-1];//状态可以从dp[i][j-1]转移
                nums[i][j]%=mod;//取余
            }
            for(int m=0;m<len2;m++){
                dp1[m]=dp2[m];
            }
            Arrays.fill(dp2,0);
        }
        System.out.println(dp1[len2-1]);
        System.out.println(nums[len1-1][len2-1]);
    }
}