BM65 最长公共子序列(二)

描述

给定两个字符串str1和str2，输出两个字符串的最长公共子序列。如果最长公共子序列为空，则返回"-1"。目前给出的数据，仅仅会存在一个最长的公共子序列
数据范围：
0≤∣str1∣,∣str2∣≤2000
要求：空间复杂度
示例1
输入：
“1A2C3D4B56”,“B1D23A456A”
复制
返回值：
“123456”

分析

这一题需要理解公共子序列的知识。公共子序列是指两个或多个序列中同时出现的子序列。换句话说，如果一个序列是另一个序列的子序列，那么它也是另一个序列的子序列。公共子序列不需要是连续的，只要它们在原始序列中的相对顺序保持不变即可。公共子序列在字符串匹配、DNA序列比对等领域有广泛的应用

所以我们要找到的不仅是两个字符中相同的字符而且位置不固定且是组成循序是连续的字符。

分两步：

第一步生成一个图表。用来记录每次遍历查询的结果，生成图表长宽要比字符长度大一，便于横轴和纵轴做对比。

    const m = s1.length
    const n = s2.length
    const dp = Array.from({length: m + 1}, () => Array(n + 1).fill(0))

第二步遍历两个字符串。如果s1中的某个字符等于s2中的某个字符。那么用上一个位置的值加一。如果不相等，那么当前位置的值等于上方或左相邻最大的一个值。在遍历结束之后，dp[m][n]所在的位置的值就是最长公共子序列的长度。

    for (let i = 1; i <= m; i ++ ) {
        for(let j = 1; j <= n; j ++) {
            if (s1[i - 1] === s2[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])
            }
        }
    }

第三步根据生成的图表反向推断最长公共子序列的字符。并返回结果。如果相等直接取当前字符，如果不相等往上找。最后将结果转成字符串，如果为空就是-1。

    let i = m;
    let j = n;
    const result = []
    while(i > 0 && j > 0) {
        if (s1[i -1] === s2[j - 1]) {
            result.unshift(s1[i - 1])
            i -= 1
            j -= 1
        } else if (dp[i - 1][j] > dp[i][j - 1]) {
            i -= 1
        } else {
            j -= 1
        }
    }
    return result.join('') || -1

如果使用的TypeScript 返回结果注解要加上数字类型

export function LCS(s1: string, s2: string): string | number {
    // write code here

全部代码

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * longest common subsequence
 * @param s1 string字符串 the string
 * @param s2 string字符串 the string
 * @return string字符串
 */
export function LCS(s1: string, s2: string): string | number {
    // write code here
   
    const m = s1.length
    const n = s2.length
    const dp = Array.from({length: m + 1}, () => Array(n + 1).fill(0))
    for (let i = 1; i <= m; i ++ ) {
        for(let j = 1; j <= n; j ++) {
            if (s1[i - 1] === s2[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])
            }
        }
    }
    let i = m;
    let j = n;
    const result = []
    while(i > 0 && j > 0) {
        if (s1[i -1] === s2[j - 1]) {
            result.unshift(s1[i - 1])
            i -= 1
            j -= 1
        } else if (dp[i - 1][j] > dp[i][j - 1]) {
            i -= 1
        } else {
            j -= 1
        }
    }
    return result.join('') || -1
}