算法设计与应用基础：第十三周（2）

376. Wiggle Subsequence

Add to List

Description Hints Submissions Solutions

• Total Accepted: 21573
• Total Submissions: 61284
• Difficulty: Medium
• Contributor: LeetCode

A sequence of numbers is called a wiggle sequence if the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with fewer than two elements is trivially a wiggle sequence. 

For example, [1,7,4,9,2,5] is a wiggle sequence because the differences (6,-3,5,-7,3) are alternately positive and negative. In contrast, [1,4,7,2,5] and [1,7,4,5,5] are not wiggle sequences, the first because its first two differences are positive and the second because its last difference is zero.

Given a sequence of integers, return the length of the longest subsequence that is a wiggle sequence. A subsequence is obtained by deleting some number of elements (eventually, also zero) from the original sequence, leaving the remaining elements in their original order.

Examples:

Input: [1,7,4,9,2,5]
Output: 6
The entire sequence is a wiggle sequence.

Input: [1,17,5,10,13,15,10,5,16,8]
Output: 7
There are several subsequences that achieve this length. One is [1,17,10,13,10,16,8].

Input: [1,2,3,4,5,6,7,8,9]
Output: 2

Follow up:
Can you do it in O(n) time?

解题思路：模拟构造的过程，首先找到第一对发生摇摆的元素，然后开始遍历检索，巧妙的地方在于对于每次遍历，最终都会修改pre的值，因为如果满足摇摆则肯定修改；如果不满足，那么当前遍历值比pre值对于之后序列发生摇摆的可能性更大，举个例子，[1,3,7,4],pre是3，当前元素是7，那么虽然7不满足摇摆，但是对于pre(3)，7比它更可能发生摇摆（结果就是1，7，4为摇摆序列；另外一种对立情况和上述原因一样。代码如下

class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
        int n=nums.size();
        if(n<2) return n;
        int i;  
        for(i=0;i<n-1;i++){//找到第一个有意义的差值  
            if(nums[i]!=nums[i+1]){  
                break;  
            }  
        }  
        if(i == (n-1)){//所有数都相同  
            return 1;  
        }
        int p,pre=nums[i+1],res=2;
        bool increasing=nums[i]<nums[i+1];
        for(p=i+2;p<n;p++){
            if(increasing&&pre>nums[p]){
                increasing=!increasing;
                res++;
            }
            else if(!increasing&&pre<nums[p]){
                    increasing=!increasing;
                    res++;
                }
            
            pre=nums[p];
        }
        return res;
    } 
};

感想：一开始这道题自己用的是找到到当前遍历元素为止的最大摇摆序列（和最终答案思路一样，但是没有想到先找到第一对摇摆元素，使得dp的初始情况比较复杂，最终也使得算法错误，本答案简化之处在于两点：1.先找到第一对摇摆值 2.局部利用贪心每次修改pre值使得最优子结构满足最终情况。