算法-动态规划-LCS 最长公共子序列

算法-动态规划-LCS 最长公共子序列

1 概述

1.1 题目出处

https://leetcode-cn.com/problems/longest-common-subsequence/

1.2 题目描述

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

示例 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 <= 1000
1 <= text2.length <= 1000
输入的字符串只含有小写英文字符。

2 题解

2.1 递归

首先我们想到的是用递归的方式，此方法思考起来比较简单，但缺点是会有重复计算，性能较低。

2.2 动态规划

2.2.1 解题思路

该问题其实就是父问题和子问题的关系，可以考虑采用动态规划算法。

记状态转移二维数组dp[i][j]表示从 字符串text1中下标 0到i-1 和 字符串text2中0到j-1 的最长公共子序列。

设dp[i][j]为字符串text1和text2的最长公共子序列，那么递推有3种情况，经过推导可以得出状态转移方程如下：

• 如果text1[i] == text2[j]，说明最后两个字符相同
  dp[i][j] = dp[i-1][j-1] + text1[i-1]

• 否则，dp[i][j]就应该等于分别去掉两个字符串的尾部字符后的公共子序列中的大者

  • 即如果len(dp[i-1][j]) >= len(dp[i][j-1])，则dp[i][j] = dp[i-1][j]，此时就暗含了去掉text1的字最后一个字符对计算结果无影响
    dp[i][j] = dp[i-1][j]

  • 否则len(dp[i][j]) = len(dp[i][j-1])，此时就暗含了去掉text2的字最后一个字符无影响
    dp[i][j] = dp[i][j-1]

从1到len遍历两个字符串，最终得到的 dp[len_text1][len_text2]便是最终结果，代表字符串a和字符串b的最长公共子序列。

2.2.2 Python代码

python实现代码如下：

# -*- coding:utf-8 -*-

# 动态规划思想求解最长公共子序列
def lcs_dynamic_planning(a, b):
    len_a = len(a)
    len_b = len(b)
    # 创建状态二维数组，注意这里为了程序求解需要，长度是len+1
    dp = [['' for i in range(len_b+1)] for j in range(len_a+1)]

    for i in range(1, len_a + 1):
        for j in range(1, len_b + 1):
            if a[i-1] == b[j-1]:
                dp[i][j] = dp[i-1][j-1] + a[i-1]
            else:
                lcs_1 = dp[i-1][j]
                lcs_2 = dp[i][j-1]
                if len(lcs_1) > len(lcs_2):
                    dp[i][j] = lcs_1
                else:
                    dp[i][j] = lcs_2
    return dp[len_a][len_b]

print(lcs_dynamic_planning('hello world', 'hero word'))

结果如下：

heo word

2.2.3 Java代码

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int[][] dp = new int[text1.length()+1][text2.length()+1];
        for(int i = 1; i <= text1.length(); i ++)
            for(int j = 1; j <= text2.length(); j ++)
                dp[i][j] = text1.charAt(i-1) == text2.charAt(j-1) ? dp[i][j] =  dp[i-1][j-1] + 1 : Math.max(dp[i][j-1], dp[i-1][j]);
        return dp[text1.length()][text2.length()];
    }
}

2.2.4 时间复杂度

O(m*n)

2.2.5 空间复杂度

O(m*n)