算法打卡day45

今日任务:

1)300.最长递增子序列

2)674.最长连续递增序列

3)718.最长重复子数组

4)复习day20

300.最长递增子序列

题目链接: 300. 最长递增子序列 - 力扣(LeetCode)

复制代码
给你一个整数数组 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

提示:
1 <= nums.length <= 2500
-10^4 <= nums[i] <= 104

文章讲解: 代码随想录 (programmercarl.com)

视频讲解: 动态规划之子序列问题,元素不连续!| LeetCode:300.最长递增子序列哔哩哔哩bilibili

思路:

这个问题可以使用动态规划来解决。我们可以定义一个状态数组dp,其中dp[i]表示以第 i 个元素结尾的最长递增子序列的长度。

具体的动态规划转移方程如下:

  • 对于dp[i],我们需要考虑第 i 个元素与前面的元素的关系:
    1. 如果 nums[i] 大于 nums[j](0 ≤ j < i),则第 i 个元素可以接在第 j 个元素后面形成一个更长的递增子序列,此时 dp[i] = max(dp[i], dp[j] + 1)
    2. 否则,第 i 个元素无法接在任何元素后面形成递增子序列,此时 dp[i] = 1(表示只有第 i 个元素自己构成一个递增子序列)。

最终的答案就是dp数组中的最大值。

python 复制代码
class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0:
            return 0

        # 初始化状态数组
        dp = [1]*n

        # 动态规划转移
        for i in range(1,n):
            for j in range(i):
                if nums[j] < nums[i]:
                    dp[i] = max(dp[i],dp[j]+1)

        # 返回dp数组中的最大值
        return max(dp)

674.最长连续递增序列

题目链接: 674. 最长连续递增序列 - 力扣(LeetCode)

复制代码
给定一个未经排序的整数数组,找到最长且 连续递增的子序列,并返回该序列的长度。
连续递增的子序列 可以由两个下标 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。

提示:
0 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9

文章讲解: 代码随想录 (programmercarl.com)

视频讲解: 动态规划之子序列问题,重点在于连续!| LeetCode:674.最长连续递增序列哔哩哔哩bilibili

思路:

这一题我们可以用动态规划,也可以用贪心 算法来解决这个问题。

动态规划:

我们可以定义一个状态数组 dp,其中 dp[i] 表示以第 i 个元素结尾的最长连续递增子序列的长度。初始时,所有元素的最长连续递增子序列长度都为1。

然后,我们可以从第二个元素开始遍历数组,对于每个位置 i,我们判断 nums[i] 是否大于 nums[i-1]

  • 如果是,则 dp[i] = dp[i-1] + 1,表示以当前元素结尾的最长连续递增子序列的长度比前一个元素多1;
  • 如果不是,则 dp[i] = 1,表示以当前元素结尾的最长连续递增子序列的长度重新开始计算。

最终,我们返回状态数组 dp 中的最大值即为所求的最长连续递增子序列的长度。

python 复制代码
class Solution:
    # 动态规划
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        n = len(nums)
        if n <= 1:
            return n

        # 初始化状态数组
        dp = [1] * n

        # 动态规划转移
        for i in range(1, n):
            if nums[i] > nums[i-1]:
                dp[i] = dp[i-1] + 1

        # 返回dp数组中的最大值
        return max(dp)

贪心算法:

我们可以遍历数组,用一个变量记录当前连续递增子序列的长度,同时维护一个变量记录最长连续递增子序列的长度。

具体步骤如下:

  1. 初始化当前连续递增子序列的长度 cur_len 和最长连续递增子序列的长度 max_len,均设为1(因为至少有一个元素构成子序列)。
  2. 从数组的第二个元素开始遍历,判断当前元素是否比前一个元素大:
    • 如果是,则当前连续递增子序列的长度加1,并更新最长连续递增子序列的长度;
    • 如果不是,则当前连续递增子序列的长度重新设为1。
  3. 最终返回 max_len 即为最长连续递增子序列的长度。
python 复制代码
class Solution:
    # 贪心算法
    def findLengthOfLCIS2(self, nums: List[int]) -> int:
        n = len(nums)
        if n <= 1:
            return n

        cur_len = 1  # 当前连续递增子序列的长度
        max_len = 1  # 最长连续递增子序列的长度

        for i in range(1, n):
            if nums[i] > nums[i - 1]:  # 当前元素比前一个元素大
                cur_len += 1
                max_len = max(max_len, cur_len)
            else:
                cur_len = 1

        return max_len

感想:

针对给定一个未经排序的整数数组,找到最长且连续递增的子序列,两种方法都可以解决,但在这种情况下,贪心算法更为简单且高效。

贪心算法的优势:

  • 在这个问题中,连续递增子序列的最大长度实际上就是最长连续递增子序列的长度。因此,我们只需要从头到尾遍历数组一次,记录当前递增序列的起始位置和长度即可。
  • 贪心算法的时间复杂度是 O(n),空间复杂度是 O(1),非常高效。

动态规划的不足:

  • 对于这个问题,使用动态规划可能会过于复杂。动态规划通常用于更复杂的问题,其中状态之间存在更复杂的依赖关系,而在这个问题中,并不需要记录每个位置的状态,只需要记录当前递增序列的起始位置和长度即可。

718.最长重复子数组

题目链接: 718. 最长重复子数组 - 力扣(LeetCode)

复制代码
给两个整数数组 A 和 B ,返回两个数组中公共的、长度最长的子数组的长度。

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

提示:
注意题目中说的子数组,其实就是连续子序列
1 <= len(A), len(B) <= 1000
0 <= A[i], B[i] < 100

文章讲解: 代码随想录 (programmercarl.com)

视频讲解: 动态规划之子序列问题,想清楚DP数组的定义 | LeetCode:718.最长重复子数组哔哩哔哩bilibili

思路:

这个问题可以用动态规划来解决。我们可以使用一个二维数组 dp,其中 dp[i][j] 表示以 A[i-1]B[j-1] 结尾的公共子数组的长度。如果 A[i-1]B[j-1] 相等,那么 dp[i][j] = dp[i-1][j-1] + 1,否则 dp[i][j] = 0

python 复制代码
class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        # 获取数组 nums1 和 nums2 的长度
        m, n = len(nums1), len(nums2)

        # 初始化动态规划数组 dp
        dp = [[0] * (n + 1) for _ in range(m + 1)]

        # 初始化最大公共子数组长度为 0
        max_len = 0

        # 遍历数组 nums1 和 nums2
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                # 如果 nums1[i-1] 和 nums2[j-1] 相等,则更新 dp[i][j] 为前一个状态加 1
                if nums1[i - 1] == nums2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                    # 更新最大公共子数组长度
                    max_len = max(max_len, dp[i][j])

        # 返回最大公共子数组长度
        return max_len
相关推荐
肥猪猪爸2 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
readmancynn2 小时前
二分基本实现
数据结构·算法
萝卜兽编程2 小时前
优先级队列
c++·算法
盼海2 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
一直学习永不止步3 小时前
LeetCode题练习与总结:最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表
Rstln3 小时前
【DP】个人练习-Leetcode-2019. The Score of Students Solving Math Expression
算法·leetcode·职场和发展
芜湖_4 小时前
【山大909算法题】2014-T1
算法·c·单链表
珹洺4 小时前
C语言数据结构——详细讲解 双链表
c语言·开发语言·网络·数据结构·c++·算法·leetcode
几窗花鸢4 小时前
力扣面试经典 150(下)
数据结构·c++·算法·leetcode
.Cnn4 小时前
用邻接矩阵实现图的深度优先遍历
c语言·数据结构·算法·深度优先·图论