376. Wiggle Subsequence

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?

• 这一题总体比较简单，用动态规划找出递归关系即可。
• nums[i] > nums[i-1], 需要查找(0~i-1)序列中的最大序列，需要考虑递增和递减的关系。len[i]表示数列（0~i）的最长序列。flag[i]用来表示符号位，表示最长序列的最后一位是递增还是递减.

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int n = nums.size();
        vector<int> len(n,0);
        vector<int> flag(n,-1);

        if(n <= 1){
            return n;
        }

        if(nums[1] == nums[0]){
            len[1] = 1;
            flag[1] = -1;
        }

        //the current element is bigger than the preive element
        if(nums[1] > nums[0]){
            flag[1] = 1;
             len[1] = 2;
        }

        //the current element is smaller than the preive element
        if(nums[1] < nums[0]){
            flag[1] = 0;
             len[1] = 2;
        }

        for(int i = 2; i < n; ++i){
            //cout<<nums[i]<<","<<end[i-1]<<endl;
            if(nums[i] > nums[i-1]){
                if(flag[i-1] == 0){
                    len[i] = len[i-1] + 1;
                   flag[i] = 1;
                }

                if(flag[i-1] == 1){
                    len[i] = len[i-1] ;
                   flag[i] = 1;
                }

                if(flag[i-1] == -1){
                    len[i] = len[i-1] + 1;
                   flag[i] = 1;
                }

            }

            if(nums[i] < nums[i-1]){
                if(flag[i-1] == 1){
                    len[i] = len[i-1] + 1;
                    flag[i] = 0;
                }

                if(flag[i-1] == 0){
                    len[i] = len[i-1];
                    flag[i] = 0;
                }

                if(flag[i-1] == -1){
                    len[i] = len[i-1] + 1;
                   flag[i] = 0;
                }
            }

            if(nums[i] == nums[i-1]){
                 len[i] = len[i-1] ;
                 flag[i] = flag[i-1];
            }


        }


        return len[n-1];
    }
};