leetcode(力扣) 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

贪心：

题目要求的是子序列，子序列可以非连续。

摆动数列，也就是，升降来回循环。贪心的话我们只需要判断当前的升降状态和前一个状态是不是反着的就行了。

细节：

• 有一个测试用例是这样的：[3,3,3,2,5]，显然要将指针移动到2的位置，也就是开头的重复值都略过。
• 只有一个值的摆动数组也算，长度就是1。包括像 [0,0]这种 也是1。
• 初始化记录答案变量res的时候，要分情况判断，如果前两个元素不相等，则设置res =2 ,如果前两个元素相等，则设置res = 1。在这块将用于升降状态记录的变量也同时初始化掉。

动态规划：

动态规划五步走：

1.确认dp数组含义：

看下面这张图，可以发现我们要计算的点要么是山峰，要么是山谷。

设dp状态dp[i][0]，表示考虑前i个数，第i个数作为山峰的摆动子序列的最长长度
设dp状态dp[i][1]，表示考虑前i个数，第i个数作为山谷的摆动子序列的最长长度

这里要注意，考虑前i个数，这i个数不一定是从0开始的。

2.状态转移公式：

• 若0 < j < i , nums[i] > nums[j] ,即当前的nums[i] 作为山峰:
  • dp[i][0] = max(dp[i][0], dp[j][1] + 1),也就是，要么是接在某个山谷后面，那么就是山谷-山峰 此时最长长度+1，要么就维持原状也就是 山峰 -山峰。
• 同理 若 0 < j < i , nums[j] > nums[i],即当前的nums[i]作为山谷：
  • dp[i][1] = max(dp[i][1], dp[j][0] + 1) ，也就是，要么是接在某个山峰后面，变成 山峰-山谷，此时最长长度+1，要么就是维持原状， 山谷-山谷。

3.初始化dp：

只有一个数字的摆动数列的长度也是1，所以dp[0][0] = dp[0][1] = 1

4.遍历顺序;
i 从0到nums末尾，j从0遍历到i。

5.返回值：
回看dp数组的含义。
返回值显然就是 dp[-1][0] 和dp [-1][1] 里的最大值。

完整代码

贪心：
class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:      
            # True 表示上升趋势， False表示下降趋势
            res = 0
            start_index = 0
            while start_index <= len(nums)-2 and nums[start_index] == nums[start_index+1]:
                start_index +=1
            if len(nums[start_index:])<=1:
                return 1
            start_index +=1
            if nums[start_index] > nums[start_index-1]:
                temp = True
                res = 2
            elif nums[start_index] < nums[start_index-1]:
                temp = False
                res +=2
            else:
                res = 1
            for i in range(start_index,len(nums)):
                if nums[i] != nums[i-1]:
                    if nums[i] < nums[i-1] and temp: # 此时为下降趋势，若前一个是上升趋势，则+1
                        res +=1
                        temp = False
                    elif nums[i] > nums[i-1] and not temp: # 此时为上升趋势，若钱一个是下降趋势则+1
                        res +=1
                        temp = True
            return res

动态规划：

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        # 0 i 作为波峰的最大长度
        # 1 i 作为波谷的最大长度
        # dp是一个列表，列表中每个元素是长度为 2 的列表
        dp = []
        for i in range(len(nums)):
            # 初始为[1, 1]
            dp.append([1, 1])
            for j in range(i):
                # nums[i] 为波谷
                if nums[j] > nums[i]:
                    dp[i][1] = max(dp[i][1], dp[j][0] + 1)
                # nums[i] 为波峰 
                if nums[j] < nums[i]:
                    dp[i][0] = max(dp[i][0], dp[j][1] + 1)
        return max(dp[-1][0], dp[-1][1])