Wiggle Subsequence解题报告

https://leetcode.com/problems/wiggle-subsequence/

这道题和最长子序列，Divisible Subset题目类似，都可以用O(n2)的时间复杂度完成。可以想象，对于第i个数，dp[i]=dp[j]+1,当且仅当dp[j]+1>dp[i]而且nums[j]和nums[i]的差值和j所处位置的差值符号相反。所以，代码如下：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()<2) return nums.size();
        vector<int> dp(nums.size(),1);
        vector<int> last(nums.size(),0);
        int res=1;
        for(int i=1;i<nums.size();i++){
            for(int j=i-1;j>=0;j--){
                if(dp[j]+1>dp[i]&&((last[j]==0&&nums[i]!=nums[j])||(last[j]>0&&nums[i]<nums[j])||(last[j]<0&&nums[i]>nums[j]))){
                    dp[i]=dp[j]+1;
                    last[i]=nums[i]>nums[j]?1:-1;
                }
                if(dp[i]>res) res=dp[i];
            }
        }
        return res;
    }
};

需要注意的是，对于nums.size()==2的情况下的处理，我开始统一返回2，后来发现误判了[1,1]这一种类型。
但是这种解法时间复杂度比较高，有另外一种解法比较巧妙，而且时间复杂度比较低。现在观察一个序列[1,4,5,6,3,2,1,7]，最长摇摆序列是4。分别是：
1,4,3,7
1,4,2,7
1,4,1,7
1,5,3,7
1,5,2,7
1,5,1,7
1,6,3,7
1,6,2,7
1,6,1,7
可以看到4,5,6所对应的摇摆序列是相同的，3,2,1所对应的摇摆序列是相同的。因为到4位置，序列的方向是上升的，所以5，6也是上升的，对序列长度不影响，其后应该下降，而且只要比4小的一定比5和6小。
所以这就提示我们找摇摆序列的最大拐点，这样的时间复杂度是O(n)

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()<2) return nums.size();
        int n=nums.size();
        int res=1;
        int i=1,j=0;
        while(i<n){
            if(nums[j]<nums[i]){
                res++;
                while(i+1<n&&nums[i]<=nums[i+1]) i++;
            }
            else if(nums[j]>nums[i]){
                res++;
                while(i+1<n&&nums[i]>=nums[i+1]) i++;
            }
            j=i;
            i++;
        }
        return res;
    }
};