LeetCode 376. Wiggle Subsequence C++

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

1. 这道题求最长摆动序列即一大一小的序列，对于最长什么什么的，第一反应会想到动态规划，不过这道题确实是可以用动态规划求解，我们先找找子问题，我们设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

1. 看了官方题解，发现可以用线性动态规划求解，时间复杂度降为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]);
    }
};