题目描述

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

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

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

示例 1:

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

# -*- coding: utf-8 -*-
# @Time         : 2019-09-22 23:32
# @Author       : Jayce Wong
# @ProjectName  : job
# @FileName     : longestCommonSubsequence.py
# @Blog         : https://sysujayce.github.io/
# @Github       : https://github.com/SysuJayce


class Solution:
    """
    首先搞清楚定义：
    假定原序列为abcdefgh，那么acfh是其中一个子序列，但不是子串
    而abcd是一个子串，同时也是一个子序列。
    因此，字符串t的子序列s的定义是在删除一些t的字符后可以得到s。
    而子串的定义是原字符串中连续的字符，子串必须能在原字符串中查找到。

    在搞清楚定义之后，可以进行分析。
    首先这是一个双序列的问题，对于双序列的问题，我们一般使用二维矩阵进行状态保存。
    假设对于序列A0A1A2...Am和序列B0B1B2...Bn来说，其最长公共子序列为C0C1C2...Ck
    一、若Am=Bn：那么说明Ck=Am=Bn，
                即反映出C0C1C2...Ck-1是A0A1A2...Am-1和B0B1B2...Bn-1的最长公共子序列。
                注意到我们由Am=Bn这个条件，将原问题分解成了一个更小的问题，这是我们DP成功的关键

    二、若Am!=Bn：
        1. Ck!=Am：说明C0C1C2...Ck是A0A1A2...Am-1和B0B1B2...Bn的最长公共子序列；
        2. Ck!=Bn：说明C0C1C2...Ck是A0A1A2...Am和B0B1B2...Bn-1的最长公共子序列；

    那么，假定dp[i][j]表示text1[:i]和text2[:j]的最长公共子序列的长度
    根据上面的分析，我们可以得到以下的状态转移方程：
                 dp[i-1][j-1] + 1，当text1[i] == text[j]时
    dp[i][j]  =  0，当i或j为0时
                 max(dp[i-1][j], dp[i][j-1])，当text1[i] != text[j]时
    """
    def longestCommonSubsequence(self, text1: str, text2: str):
        # 首先将text1和text2的前面补一个空格，这样方便编程
        # 因为dp[i][j]就是text1[:i]和text2[:j]的最长公共子序列的长度
        text1 = ' ' + text1
        text2 = ' ' + text2
        rows = len(text1)
        cols = len(text2)
        # 初始化状态矩阵为0
        dp = [[0] * cols for _ in range(rows)]
        for i in range(1, rows):
            for j in range(1, cols):
                # 对于每一个i和j，根据上面的转移方程进行计算
                if text1[i] == text2[j]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])

        # 末尾元素就是我们所需计算的长度
        maxlen = dp[-1][-1]
        res = self.findAllLCS(dp, text1, text2)
        return maxlen, res

    def findAllLCS(self, dp, text1, text2):
        """
        要从已经计算好的状态矩阵中找出所有的最长公共子序列，我们需要关注的是当出现向上和向左都可以
        的时候，需要保持方向的一致，向上就一直向上，向左就一直向左，否则会出现问题。
        """
        def helper(i, j, s):
            while i > 0 and j > 0:
                # 如果text1和text2在当前位置的字符相等，直接加入到当前查找到的字符串的前面
                # 因为我们是反向查找的，所以加到前面去
                if text1[i] == text2[j]:
                    s = text1[i] + s
                    i -= 1
                    j -= 1
                else:
                    # 如果当前位置的字符不相等，需要选择向上还是向左
                    # 如果只有一个方向可选，那就选那个可选的方向
                    if dp[i - 1][j] > dp[i][j - 1]:
                        # 这里是向上
                        i -= 1
                    elif dp[i - 1][j] < dp[i][j - 1]:
                        # 这里是向左
                        j -= 1
                    else:
                        # 如果两个方向都可以，那么我们可以递归调用这个函数，把当前的位置信息
                        # 和已找到的字符串传入。
                        # 分别向上和向左走，这样就可以保证方向的一致性
                        helper(i - 1, j, s)
                        helper(i, j - 1, s)
                        # 由于我们这里选择了方向之后没有在当前函数改变i和j，因此我们需要结束
                        # 当前的迭代，但是不能用break
                        # 因为用break的话，后面加入的s会错乱，会包含小于最长长度的子序列
                        return
            res.append(s)

        rows, cols = len(dp), len(dp[0])
        res = []
        helper(rows - 1, cols - 1, '')
        return res


def main():
    solution = Solution()
    text1 = "abcbdab"
    text2 = "bdcaba"
    maxlen, res = solution.longestCommonSubsequence(text1, text2)
    print(maxlen)
    print(res)


if __name__ == '__main__':
    main()