代码随想录算法训练营第五十二天| LeetCode300. 最长递增子序列、LeetCode674. 最长连续递增序列、LeetCode718. 最长重复子数组

一、LeetCode300. 最长递增子序列

        1：题目描述（300. 最长递增子序列）

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

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

        2：解题思路

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        # 确认dp数组的含义
        # dp[i]表示i之前包括i的以nums[i]结尾最长上升子序列的长度
        # 确认递推公式
        # 位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
        # 所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
        # 注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值
        # dp[i]的初始化
        # 每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是1.
        # 遍历顺序
        # dp[i] 是有0到i-1各个位置的最长升序子序列 推导而来，那么遍历i一定是从前向后遍历
        nums_len = len(nums)
        if nums_len == 0:
            return 0
        dp = [1] * nums_len
        for i in range(nums_len):
            for j in range(0, i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j]+1)
        return max(dp)

二、LeetCode674. 最长连续递增序列

        1：题目描述（674. 最长连续递增序列）

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

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

        2：解题思路

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        # 确认dp数组的含义
        # dp[i]表示i之前包括i的以nums[i]结尾最长连续递增子序列的长度
        # 确定递推公式
        # if nums[i+1] > nums[i]: 说明是连续递增的
        # dp[i+1] = dp[i]+1
        # 初始化
        # 每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是1
        # 遍历顺序
        # 由递推公式可以看出，需要从前往后进行遍历
        nums_len = len(nums)
        if nums_len == 0:
            return 0
        dp = [1] * nums_len
        for i in range(nums_len-1):
            if nums[i] < nums[i+1]:
                dp[i+1] = dp[i]+1
        return max(dp)

三、LeetCode718. 最长重复子数组

        1：题目描述（718. 最长重复子数组）

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

        2：解题思路

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        # 确认dp数组的含义
        # dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]
        # 确定递推公式
        # 根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。
        # 即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
        # 根据递推公式可以看出，遍历i 和 j 要从1开始！
        # 初始化
        # 根据dp[i][j]的定义，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。
        # 遍历顺序
        # 外层for循环遍历A，内层for循环遍历B
        nums1_len = len(nums1)
        nums2_len = len(nums2)
        if nums1_len == 0 or nums2_len == 0:
            return 0
        dp = [[0] * (nums2_len+1) for _ in range(nums1_len+1)]
        reslut = 0
        for i in range(1, nums1_len+1):
            for j in range(1, nums2_len+1):
                if nums1[i-1] == nums2[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                if dp[i][j] > reslut: reslut = dp[i][j]
        return reslut