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?
Approach
- 这道题求最长摆动序列即一大一小的序列,对于最长什么什么的,第一反应会想到动态规划,不过这道题确实是可以用动态规划求解,我们先找找子问题,我们设
dp[0][i]
为以大的数为结尾的最长序列长度,dp[1][i]
为以小的数为结尾的最长序列长度,根据序列定义,可知子问题最初的方程当 a>b nums[a]>nums[b] dp[0][a]=1+1; 当 a>b nums[a]<nums[b] dp[1][a]=1+1
,接着要想怎么得让它得利益最大化,首先我们是不知道b
后面是否也跟着一段摆动序列,如果有的话,肯定是要加上的,因为我们要尽可能长,所以方程又变为为当 a>b nums[a]>nums[b] dp[0][a]=1+dp[1][b]; 当 a>b nums[a]<nums[b] dp[1][a]=1+dp[0][b]
,但是以b
为结尾的摆动序列,未比是最长的,所以我们要更加长,方程又变为当 a>b nums[a]>nums[b] dp[0][a]=max(1+dp[1][b],dp[0][a]); 当 a>b nums[a]<nums[b] dp[1][a]=max(1+dp[0][b],dp[1][a])
,即最终的状态转移方程,然后最后还是要遍历一遍数组,因为不知道序列的尾部在哪。 4ms
Code
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
vector<vector<int>> dp(2, vector<int>(nums.size(),1));
for (int i = 0; i < nums.size(); i++) {
for (int j = i + 1; j < nums.size(); j++) {
if (nums[i] < nums[j]) {
dp[0][j] = max(dp[0][j], dp[1][i] + 1);
}
else if(nums[i]>nums[j]){
dp[1][j] = max(dp[1][j], dp[0][i] + 1);
}
}
}
int maxn = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < nums.size(); j++) {
maxn = max(maxn, dp[i][j]);
}
}
return maxn;
}
};
Again
- 看了官方题解,发现可以用线性动态规划求解,时间复杂度降为O(n),思路基本差不多,看代码思路会更加清晰,就不再复述思路了。
Code
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
if (nums.size() <2)return nums.size();
vector<int> up(nums.size(), 0);
vector<int> down(nums.size(), 0);
up[0] = down[0] = 1;
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) {
up[i] = down[i - 1] + 1;
down[i] = down[i - 1];
}
else if (nums[i] < nums[i - 1]) {
down[i] = up[i - 1] + 1;
up[i] = up[i - 1];
}
else {
down[i] = down[i - 1];
up[i] = up[i - 1];
}
}
return max(up[nums.size() - 1], down[nums.size() - 1]);
}
};