最长递增子序列(LIS)+最长公共子序列(LCS)+最长公共递增子序列(LICS)

 做题笔记===

 最长递增子序列(LIS)问题

 最长递增子序列（LIS）问题是一个经典的动态规划问题，其目标是找到给定序列中的最长递增子序列的长度。递增子序列是指序列中的元素按照顺序排列，并且每个元素都大于前面的元素。

让我们通过一个具体的例子来说明最长递增子序列（LIS）问题的解法。

假设我们有一个序列：3,4,1,5,7,2,6

我们的目标是找到这个序列的最长递增子序列。

我们首先初始化这个数组为1,1,1,1,1,1,1，因为每个元素本身都可以作为一个长度为1的递增子序列。

然后，我们从第二个元素开始遍历序列，对于每个元素，我们遍历它之前的所有元素，并更新以当前元素结尾的最长递增子序列的长度。具体地说，如果当前元素大于之前的某个元素，并且以该元素结尾的最长递增子序列长度加一大于当前元素结尾的最长递增子序列长度，则更新当前元素结尾的最长递增子序列长度。

最后，我们返回这个数组中的最大值，即为原序列的最长递增子序列的长度。

在这个例子中，最长递增子序列是3,4,5,7，长度为4。

def length_of_lis(nums):
    if not nums:
        return 0

    n = len(nums)
    dp = [1] * n  # 初始化dp数组，每个数字自身可以作为一个递增子序列

    for i in range(1, n):
        for j in range(i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)  # 更新dp数组，表示以第i个数字结尾的最长递增子序列长度

    return max(dp)  # 返回dp数组中的最大值，即最长递增子序列的长度

if __name__ == "__main__":
    nums = list(map(int, input().split()))

    result = length_of_lis(nums)
    print(result)

最长公共子序列(LCS)问题 

最长公共子序列（LCS）问题是一个经典的动态规划问题，其目标是找到两个给定序列的最长公共子序列的长度。公共子序列是指在两个序列中以相同顺序出现的一组字符（不一定连续）。

让我们通过一个具体的例子来说明最长公共子序列（LCS）问题的解法。

假设我们有两个序列：

序列1：ABCBDAB
序列2：BDCABB

我们首先创建一个二维数组来存储两个序列之间的所有可能的公共子序列的长度。

在这个二维数组中，每个位置(i, j)表示序列1的前i个字符和序列2的前j个字符之间的公共子序列长度。我们从左上角开始，根据序列1和序列2的字符来填充数组。

最后，我们可以看到右下角的值为4，即为序列1和序列2的最长公共子序列的长度。

def LCS(text1, text2):
    m, n = len(text1), len(text2)
    # 初始化dp数组，其中dp[i][j]表示text1的前i个字符和text2的前j个字符的LCS长度
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if text1[i - 1] == text2[j - 1]:
                # 如果当前字符相同，LCS长度加一
                dp[i][j] = dp[i - 1][j - 1] + 1 
            else:
                # 如果当前字符不同，取左边或上边的最大值作为LCS长度
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    # 返回text1和text2的最长公共子序列的长度
    return dp[m][n]  

if __name__ == "__main__":
    text1 = input().strip()
    text2 = input().strip()

    result = LCS(text1, text2)
    print(result)

 最长公共递增子序列(LICS)

最长公共递增子序列（LICS）问题是一个扩展的动态规划问题，与最长公共子序列（LCS）问题类似，但它要求找到两个序列中的最长公共递增子序列的长度。公共递增子序列是指在两个序列中以相同顺序出现的一组数字，并且这组数字是递增的。

假设我们有两个序列：

序列1：[1, 3, 5, 2, 4]
序列2：[2, 4, 1, 3, 5]

我们可以使用动态规划来解决这个问题。我们首先创建一个二维数组来存储两个序列之间的所有可能的公共递增子序列的长度，并且在填充数组时，只有当当前元素比前一个元素大时，我们才能将它添加到公共递增子序列中。

在这个二维数组中，每个位置(i, j)表示序列1的前i个数字和序列2的前j个数字之间的公共递增子序列长度。我们从左上角开始填充数组，并且只有当当前元素大于前一个元素时才更新数组中的值。

最后，数组中的右下角的值即为序列1和序列2的最长公共递增子序列的长度。

def LCIS(seq1, seq2):
    m, n = len(seq1), len(seq2)
    dp = [[0] * (n) for _ in range(m)]

    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = dp[i - 1][j]
            if seq1[i] == seq2[j]:
                for k in range(1, j):
                    if seq2[j] > seq2[k]:
                        dp[i][j] = max(dp[i][j], dp[i - 1][k] + 1)

    return max(dp[-1])


seq1 = [0] + [1, 3, 5, 2, 4]
seq2 = [0] + [2, 4, 1, 3, 5]
print(LCIS(seq1, seq2))

优化思路：其实根据前面的代码 if seq1[i] == seq2[j]:，我们知道seq[i]和seq[j]是相等的所以

if seq2[j] > seq2[k]:也可以写if seq1[i] > seq2[k]:

而

for k in range(1, j):
    if seq2[j] > seq2[k]:
         dp[i][j] = max(dp[i][j], dp[i - 1][k] + 1)

这部分代码主要是为了更新maxv也就是最大子串的动态值，这里的maxv就是你求最大子串时

dp[i] = max(dp[i], dp[j] + 1)

dp[i]的值（这是LIS那里的代码），

if seq1[i] == seq2[j]:

满足这个代码是是为了在相等时更新dp[i][j]的值

所以我们可以利用前缀和的思想用一个maxv记录最大子串的动态值，将循环给去掉

def LCIS(seq1, seq2):
    m, n = len(seq1), len(seq2)
    dp = [[0] * (n) for _ in range(m)]

    for i in range(1, m):
        maxv = 1
        for j in range(1, n):
            dp[i][j] = dp[i - 1][j]
            if seq1[i] == seq2[j]:
                dp[i][j] = max(dp[i][j], maxv)
            if seq2[j] < seq1[i]:
                maxv = max(maxv, dp[i - 1][j] + 1)
                # for k in range(1, j):
                #     if seq2[j] > seq2[k]:
                #         dp[i][j] = max(dp[i][j], dp[i - 1][k] + 1)

    return max(dp[-1])

n = int(input())
seq1 = [0] + list(map(int,input().split()))
seq2 = [0] + list(map(int,input().split()))
print(LCIS(seq1, seq2))