day42 代码随想录 | 子序列问题 面试高频题

300.最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

• 输入：nums = [10,9,2,5,3,7,101,18]
• 输出：4
• 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

注意这个题是子序列，并不要求连续。因此会有会有双层遍历. 使用动态规划

1. 确认dp数组定义

dp[i] 代表下表i及其之前的最大递增子序列的长度

2. 确定递推公式

你要明确从哪些地方可以进行推出来

由于是递增 我们需要取遍历数组

如果 nums[i] > nums[j]

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

注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值。

如果不是，不用做操作

3. dp数组初始化

dp初始化为1

4. 遍历顺序

dp[i] 是有0到i-1各个位置的最长递增子序列 推导而来，那么遍历i一定是从前向后遍历。

j其实就是从0遍历到i-1，从前到后 从后到前都无所谓。

def lengthOfLIS(nums: List[int]) -> int:
    dp = [1] * len(nums)
    result = 0
    for i in range(1, len(nums)):
        for j in range(0, i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[j] + 1, dp[i])

        result = max(dp[i], result)

    return result

674. 最长连续递增序列

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。 

这个题与上面的题目的区别在于这个是要连续的，其实就降低了难度。

因为我们单层遍历就可以了

1. dp数组定义

dp[i] 表示[0,i]之间的最大连续子序列的长度

2. dp递推公式

如果nums[i+1] > nums[i]

dp[i] = dp[i-1] + 1

如果没有dp[i] = 1

3. dp初始化

dp初始化为1

4. dp遍历顺序

正向遍历

def findLengthOfLCIS(nums: List[int]) -> int:
    dp = [1] * len(nums)

    result = 1

    for i in range(1, len(nums):
        if nums[i] > nums[i-1]:
            dp[i] = dp[i-1] + 1

        else:
            dp[i] = 1

        result = max(dp[i], result)

    return result

718. 最长重复子数组

给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。

输入：

• A: [1,2,3,2,1]
• B: [3,2,1,4,7]
• 输出：3
• 解释：长度最长的公共子数组是 [3, 2, 1] 。

子数组是连续的，而且这个题有两个数组，我们可以用dp二维数组来模拟

1. dp数组定义

dp[i][j] 表示A [0, i-1] B[0, j-1]之间的最长的重复子数组的长度。

2. dp数组推导

通过定义

如果 A[i-1] == B[j-1]

dp[i][j] = dp[i-1][j-1] + 1

3. dp数组初始化

dp[i][0] dp[0][j] 是没有意义的

但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;

所以dp[i][0] 和dp[0][j]初始化为0。

举个例子A[0]如果和B[0]相同的话，dp[1][1] = dp[0][0] + 1，只有dp[0][0]初始为0，正好符合递推公式逐步累加起来。

4. 循环遍历

外层循环A 内存循环B 都是从左到右 也可也先B后A

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        dp = [[0] * (len(nums2) + 1) for _ in range(len(nums1)+1)]
        result = 0
        for i in range(1, len(nums1) + 1):
            for j in range(1, len(nums2) + 1):
                if nums1[i-1] == nums2[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                if dp[i][j] > result:
                    result = dp[i][j]

        return result

1143.最长公共子序列

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

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

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

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

示例 1:

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

这个题与上面的题不同在于 不是连续的，他只是要求子序列

定义与上面相同

不同在于递推公式

如果相等

dp[i][j] = dp[i-1][j-1] + 1

如果不相等 就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。

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

因为这里不要求连续，仍然可以比较

初始化dp应该为0

def longestCommonSubsequence(self, text1: str, text2: str) -> int:
    dp = [[0] * (len(text2)+1) for _ in range(len(text1) + 1)]
    result = 0
    for i in range(1, len(text1) + 1):
        for j in range(1, len(text2) + 1):
            if text1[i-1] == text2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j],dp[i][j-1])

            result = max(dp[i][j], result)

    return result