Leetcode学习计划之动态规划入门day18(300,376)

最新推荐文章于 2023-11-15 23:27:21 发布

笨牛慢耕

最新推荐文章于 2023-11-15 23:27:21 发布

阅读量259

点赞数 1

分类专栏： leetcode 文章标签：算法 leetcode python 动态规划

本文链接：https://blog.csdn.net/chenxy_bwave/article/details/124652700

版权

leetcode 专栏收录该内容

194 篇文章 4 订阅

订阅专栏

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

提示：

1 <= nums.length <= 2500
-10^4 <= nums[i] <= 10^4

进阶：能将算法的时间复杂度降低到 O(n log(n)) 吗?

思路与算法

记 $dp(i)$ 表示从开始到索引 $i$ 为止、且包含 $nums[i]$ 的最长严格递增子序列的长度。在 $dp(j), j=0,...,i-1$ 都已知的条件下，可以得到状态转移方程如下所示：

$dp(i) = \max\limits_{j\in[0,i) \ and \ nums[j]<nums[i]}{dp(j)+1}$

dp数组初始化为全1，因为根据定义，最短的最长严格递增子序列的长度为1.

代码

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

执行用时：3232 ms, 在所有 Python3 提交中击败了53.83%的用户

内存消耗：15.3 MB, 在所有 Python3 提交中击败了12.70%的用户

以上是 $O(n^2)$ 时间复杂度加 $O(n)$ 空间复杂度。官解还给出了个“贪心 + 二分查找”方法，时间复杂度可以 $O(nlogn)$ ，不过看起来有点头晕，不纠结了。

376. 摆动序列

问题描述

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。

例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。
相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。

示例 1：

输入：nums = [1,7,4,9,2,5]
输出：6
解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。

示例 2：

输入：nums = [1,17,5,10,13,15,10,5,16,8]
输出：7
解释：这个序列包含几个长度为 7 摆动序列。
其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。

示例 3：

输入：nums = [1,2,3,4,5,6,7,8,9]
输出：2

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000

进阶：你能否用 O(n) 时间复杂度完成此题?

思路与算法

借鉴上题思路，记记 $dp(i)$ 表示从开始到索引 $i$ 为止、且包含 $nums[i]$ 的最长摆动序列的长度，考虑状态转移方程，可以分以下两种情况：

case1: 如果nums[i]-nums[i-1]与nums[i-1]-nums[i-2]符号相反，则 $dp(i) = 1 + dp(i-1)$
case2: 否则， $dp(i) = dp(i-1)$

但是，以上状态转移方程仅在每两个相邻的数都不相同情况下才成立。

所以可以考虑先对原数组做一个预处理，删除连续相同的冗余元素，然后再按照以上方式进行动态规划求解。

代码

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        # pre-processing
        k = 1
        ptr = 1
        while k <= len(nums)-1:
            if nums[k] == nums[ptr-1]:
                k += 1
            else:
                nums[ptr] = nums[k]
                k += 1
                ptr += 1
        if ptr == 1:
            return 1
            
        dp = ptr*[1]
        dp[1] = 2 if nums[1]!=nums[0] else 1
        for i in range(2,ptr):
            if (nums[i]-nums[i-1])*(nums[i-1]-nums[i-2])<0:
                dp[i] = dp[i-1]+1
            else:
                dp[i] = dp[i-1]
        return max(dp)

执行用时：40 ms, 在所有 Python3 提交中击败了48.39%的用户

内存消耗：15.1 MB, 在所有 Python3 提交中击败了9.22%的用户

想了想，由于dp(i)只依赖于dp(i-1)，因此并不需要维护整个dp数组，而是采用滚动数组的方式，只维持当前值。循环结束时得到的值即为所求解。

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        # pre-processing
        k = 1
        ptr = 1
        while k <= len(nums)-1:
            if nums[k] == nums[ptr-1]:
                k += 1
            else:
                nums[ptr] = nums[k]
                k += 1
                ptr += 1
        if ptr == 1:
            return 1

        dp = 2
        for i in range(2,ptr):
            if (nums[i]-nums[i-1])*(nums[i-1]-nums[i-2])<0:
                dp = dp+1
            else:
                pass
        return dp

执行用时：40 ms, 在所有 Python3 提交中击败了48.39%的用户

内存消耗：15 MB, 在所有 Python3 提交中击败了20.15%的用户

回到总目录：笨牛慢耕的Leetcode每日一题总目录(动态更新。。。)