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