day49 300.最长递增子序列 674. 最长连续递增序列 718. 最长重复子数组

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 。

示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        dp=[1 for i in range(len(nums))] #dp[i]表示以nums[i]为结尾的最长子序列长度
        for i in range(len(nums)):
            for j in range(i):
                if nums[i]>nums[j]:
                    dp[i]=max(dp[i],dp[j]+1)
        return max(dp)

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 隔开。 

示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        dp=[1 for i in range(len(nums))]
        for i in range(1,len(nums)):
            if nums[i-1]<nums[i]:
                dp[i]=dp[i-1]+1
        return max(dp)

718. 最长重复子数组

提示

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

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。

示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        dp=[[0 for i in range(len(nums1)+1)] for j in range(len(nums2)+1)] #dp用来记录两重for循环的结果 nums1[i-1],nums2[j-1]为结尾相等的最长子数组
        result=0
        for i in range(1,len(nums2)+1):
            for j in range(1,len(nums1)+1):
                if(nums2[i-1]==nums1[j-1]):
                    dp[i][j]=dp[i-1][j-1]+1
                if dp[i][j]>result:
                    result=dp[i][j]
        return result

392. 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

 

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
               # 创建一个二维数组 dp，用于存储最长公共子序列的长度
        dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
        
        # 遍历 s 和 t，填充 dp 数组
        for i in range(1, len(s) + 1):
            for j in range(1, len(t) + 1):
                if s[i - 1] == t[j - 1]:
                    # 如果 s[i-1] 和 t[j-1] 相等，则当前位置的最长公共子序列长度为左上角位置的值加一
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    # 如果 s[i-1] 和 t[j-1] 不相等，则当前位置的最长公共子序列长度为左方的较大值
                    dp[i][j] = dp[i][j - 1] 
        
        # 返回最长公共子序列的长度
        return dp[len(s)][len(t)]==len(s)