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

题目描述

LeetCode链接：最长公共子序列

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

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

例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

思路

str1[0…i]和str2[0…j]，这个范围上最长公共子序列长度是多少？
可能性分类:
a) 最长公共子序列，一定不以str1[i]字符结尾、也一定不以str2[j]字符结尾
b) 最长公共子序列，可能以str1[i]字符结尾、但是一定不以str2[j]字符结尾
c) 最长公共子序列，一定不以str1[i]字符结尾、但是可能以str2[j]字符结尾
d) 最长公共子序列，必须以str1[i]字符结尾、也必须以str2[j]字符结尾
注意：a)、b)、c)、d)并不是完全互斥的，他们可能会有重叠的情况
但是可以肯定，答案不会超过这四种可能性的范围
那么我们分别来看一下，这几种可能性怎么调用后续的递归。
a) 最长公共子序列，一定不以str1[i]字符结尾、也一定不以str2[j]字符结尾
如果是这种情况，那么有没有str1[i]和str2[j]就根本不重要了，因为这两个字符一定没用啊
所以砍掉这两个字符，最长公共子序列 = str1[0…i-1]与str2[0…j-1]的最长公共子序列长度(后续递归)
b) 最长公共子序列，可能以str1[i]字符结尾、但是一定不以str2[j]字符结尾
如果是这种情况，那么我们可以确定str2[j]一定没有用，要砍掉；但是str1[i]可能有用，所以要保留
所以，最长公共子序列 = str1[0…i]与str2[0…j-1]的最长公共子序列长度(后续递归)
c) 最长公共子序列，一定不以str1[i]字符结尾、但是可能以str2[j]字符结尾
跟上面分析过程类似，最长公共子序列 = str1[0…i-1]与str2[0…j]的最长公共子序列长度(后续递归)
d) 最长公共子序列，必须以str1[i]字符结尾、也必须以str2[j]字符结尾
同时可以看到，可能性d)存在的条件，一定是在str1[i] == str2[j]的情况下，才成立的
所以，最长公共子序列总长度 = str1[0…i-1]与str2[0…j-1]的最长公共子序列长度(后续递归) + 1(共同的结尾)
综上，四种情况已经穷尽了所有可能性。四种情况中取最大即可
其中b)、c)一定参与最大值的比较，
当str1[i] == str2[j]时，a)一定比d)小，所以d)参与
当str1[i] != str2[j]时，d)压根不存在，所以a)参与
但是再次注意了！
a)是：str1[0…i-1]与str2[0…j-1]的最长公共子序列长度
b)是：str1[0…i]与str2[0…j-1]的最长公共子序列长度
c)是：str1[0…i-1]与str2[0…j]的最长公共子序列长度
a)中str1的范围 < b)中str1的范围，a)中str2的范围 == b)中str2的范围
所以a)不用求也知道，它比不过b)啊，因为有一个样本的范围比b)小啊！
a)中str1的范围 == c)中str1的范围，a)中str2的范围 < c)中str2的范围
所以a)不用求也知道，它比不过c)啊，因为有一个样本的范围比c)小啊！
至此，可以知道，a)就是个垃圾，有它没它，都不影响最大值的决策
所以，当str1[i] == str2[j]时，b)、c)、d)中选出最大值
当str1[i] != str2[j]时，b)、c)中选出最大值

代码实现

给出暴力递归和动态规划两种实现

class LongestCommonSubsequence:
    """
    最长公共子序列
    https://leetcode.cn/problems/longest-common-subsequence/
    """
    def solution1(self, s1, s2):
        """
        暴力递归
        :param s1:
        :param s2:
        :return:
        """
        if not s1 or not s2:
            return 0
        return self.process1(s1, s2, len(s1)-1, len(s2)-1)

    def process1(self, str1, str2, i, j):
        """
        str1[0...i]和str2[0...j]，这个范围上最长公共子序列长度是多少？
        可能性分类：
        a) 最长公共子序列，一定不以str1[i]字符结尾、也一定不以str2[j]字符结尾
        b) 最长公共子序列，可能以str1[i]字符结尾、但是一定不以str2[j]字符结尾
        c) 最长公共子序列，一定不以str1[i]字符结尾、但是可能以str2[j]字符结尾
        d) 最长公共子序列，必须以str1[i]字符结尾、也必须以str2[j]字符结尾
        注意：a)、b)、c)、d)并不是完全互斥的，他们可能会有重叠的情况
        但是可以肯定，答案不会超过这四种可能性的范围
        :param s1:
        :param s2:
        :param i:
        :param j:
        :return:
        """
        if i == 0 and j == 0:
            return 1 if str1[i] == str1[j] else 0
        elif i == 0:
            if str[i] == str[j]:
                return 1
            else:
                self.process1(str1, str2, i, j-1)
        elif j == 0:
            if str[i] == str[j]:
                return 1
            else:
                self.process1(str1, str2, i-1, j)
        else:  # 此时 i != 0 且 j != 0，str1[0...i]和str2[0...i]，str1和str2都不只一个字符
            # 最长公共子序列，一定不以str1[i]字符结尾、但是可能以str2[j]字符结尾
            p1 = self.process1(str1, str2, i-1, j)
            # 最长公共子序列，可能以str1[i]字符结尾、但是一定不以str2[j]字符结尾
            p2 = self.process1(str1, str2, i, j-1)
            if str1[i] ==  str2[j]:
                p3 = self.process1(str1, str2, i-1, j-1)+1
                return max(p1, p2, p3)
            else:
                return max(p1, p2)

    def solution2(self, s1, s2):
        """
        动态规划
        :param s1:
        :param s2:
        :return:
        """
        if not s1 or not s2:
            return 0
        n, m = len(s1), len(s2)
        dp = [[0] * m for _ in range(n)]
        for i in range(n):
            dp[i][0] = 1 if s1[i] == s2[0] else dp[i-1][0]
        for j in range(m):
            dp[0][j] = 1 if s1[0] == s2[j] else dp[0][j-1]
        for i in range(1, n):
            for j in range(1, m):
                p1 = dp[i-1][j]
                p2 = dp[i][j-1]
                p3 = dp[i-1][j-1]+1 if s1[i] == s2[j] else 0
                dp[i][j] = max(p1, p2, p3)
        return dp[n-1][m-1]