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];};