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?

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int n = nums.size();
        if(n == 0) return 0;
        if(n == 1) return 1;
        int ans = -1;
        while(!dq1.empty()) dq1.pop_back();
        while(!dq2.empty()) dq2.pop_back();
        memset(lmax, -1, sizeof(lmax));
        memset(lmin, -1, sizeof(lmin));
        memset(clmax, -1, sizeof(clmax));
        memset(clmin, -1, sizeof(clmin));
        memset(dp, -1, sizeof(dp));
        dq1.push_back(0);
        dq2.push_back(0);
        for(int i = 1; i < n; ++i) {
            while(!dq1.empty() && nums[dq1.back()] >= nums[i]) dq1.pop_back();
            if(!dq1.empty()) lmin[i] = dq1.back();
            dq1.push_back(i);
            while(!dq2.empty() && nums[dq2.back()] <= nums[i]) dq2.pop_back();
            if(!dq2.empty()) lmax[i] = dq2.back();
            dq2.push_back(i);
        }
        clmin[0] = clmax[0] = 0;
        for(int i = 1; i < n; ++i) {
            if(nums[i] >= nums[i-1]) clmin[i] = clmin[i-1];
            else clmin[i] = i;
            if(nums[i] <= nums[i-1]) clmax[i] = clmax[i-1];
            else clmax[i] = i;
        }
        for(int i = 0; i < n; ++i) {
            if(lmin[i] == -1) {
                dp[i][1] = 1;
            } else {
                dp[i][1] = dp[clmin[lmin[i]]][0] + 1;
            }
            if(lmax[i] == -1) {
                dp[i][0] = 1;
            } else {
                dp[i][0] = dp[clmax[lmax[i]]][1] + 1;
            }
            ans = max(ans, dp[i][0]);
            ans = max(ans, dp[i][1]);
        }
        return ans;
    }
private:
    deque<int> dq1;
    deque<int> dq2;
    int lmax[100010];
    int lmin[100010];
    int clmin[100010];
    int clmax[100010];
    int dp[100010][2];
};