Javascript(JS) leetcode 1143. 最长公共子序列

1143. 最长公共子序列

难度中等942收藏分享切换为英文接收动态反馈

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

• 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。

提示：

• 1 <= text1.length, text2.length <= 1000
• text1 和 text2 仅由小写英文字符组成。

思路：动态规划

1、两个字符串的长度分别为m,n。采用一个dp[m][n]数组存储text1[0:i]和text2[0:j]时的最长公共子序列长度

2、dp第0行和第0列均为0，

        如果text1中下标为i-1的字符和text2中下标为j-1的字符不同，则dp[i][j]取dp[i-1][j]和dp[i][j-1]中的较大者；

        如果text1中下标为i-1的字符和text2中下标为j-1的字符相同,则dp[i][j]为dp[i-1][j-1]+1

3.最终dp[m][n]即为最长公共子序列长度

如果想要输出最长子序列，则需要从dp[m][n]动态回溯

1、如果dp[i][j]比p[i-1][j]和dp[i][j-1]都大，则一定出现了新公共字符，即text1[i-1]，将此字符放入结果串中。为避免重复需要设置计数位count，初值为最长公共子串长度，拿到一个公共字符后将count--，每次发现新字符并且该位置dp[i][j]===count再放入结果中

2、回溯法得到的公共子串和我们想要的顺序是相反的，需要翻转之后返回。

var longestCommonSubsequence = function(text1, text2) {
  const m = text1.length,n = text2.length
  let dp = new Array(m+1).fill(0).map(m => new Array(n+1).fill(0))
  for(let i = 1;i < m + 1;i++){
    for(let j = 1;j < n + 1;j++){
      if(text1[i-1] === text2[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])
      }
    }
  }
  function Subsequence(text1,dp){
    quence = ''
    count = dp[m][n]
    for(let i = m;i > 0;i--){
      for(let j = n;j > 0;j--){
        if(dp[i][j] > dp[i-1][j] && dp[i][j] > dp[i][j-1] && dp[i][j] === count){
          quence += text1[i - 1]
          count--
        }
      }
    }
    return quence
  }
  console.log(Subsequence(text1,dp).split('').reverse().join(''))
  return dp[m][n]
};

 时间复杂度：O(mn)

 空间复杂度：O(mn)