Wiggle Subsequence 摆动序列

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。

例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

示例:

输入: [1,7,4,9,2,5]
输出: 6
解释: 整个序列就是一个摆动序列。

输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 它的几个子序列满足摆动序列。其中一个是[1,17,10,13,10,16,8]。

输入: [1,2,3,4,5,6,7,8,9]
输出: 2

进阶:
你能否用 O(n) 时间复杂度完成此题?

思路：这道题标注的是用动态规划和贪心法做，我们先拉寻找规律，比如输入[1,17,5,10,13,15,10,5,16,8]，我们定义两个数组dp[i]到第i个元素为止有几个摆动序列（正表示第i个元素是上升的元素，负表示第i个元素是下降的元素），position[i]表示第i个元素的值（和nums[i]对应相等，可以不要），我们来找规律：

输入1，dp[0]=1

输入1,17，dp[1]=2

输入1,17,5，dp[2]=-3（这里刚好前三个数满足波浪形状，所以不用分析，接着看后面的如何分析）

输入1,17,5,10，dp[3]=4

输入1,17,5,10,13，因为10已经是上升元素（10>5），所以13不能再上升，我们需要一个下降元素即dp[j]（0<=j<=3 ，j是下标）小于0的进行更新且满足更新后dp[4]不小于dp[3]，所以我们从j=0比较到j=3，发现dp[2]满足条件，所以dp[4]=abs(dp[2])+1=4

输入1,17,5,10,13,15，因为dp[4]=4>0是上升元素，所以dp[5]不能取dp[4]+1，而是要取一个下降元素，从dp[j]（0<=j<=4）中取且满足不小于dp[4]，所以取dp[2]，然后计算dp[5]=abs(dp[2])+1=4

输入1,17,5,10,13,15,10，因为dp[5]=4>0是上升元素，且10-15<0，刚好是一个下降元素，所以取dp[5]+1的负数，即dp[6]=-(dp[5]+1)=5

以此类推，后面不举例了，我们可以看出规律是，我们维护一个一维数组dp，当我们要更新dp[i]时：先判断nums[i]-nums[i-1]是正还是负，

如果是正，判断dp[i-1]是否小于0，如果不是一直向前找到第一个小于0的dp的元素dp[k]，然后更新dp[i]=-dp[k]+1（dp[k]是负值），如果dp[i-1]是负值，同样更新dp[i]=-dp[i-1]+1。

如果是负，判断dp[i-1]是否大于0，如果不是一直向前找到第一个大于0的dp的元素dp[k]，然后更新dp[i]=-(dp[k]+1)（dp[k]是正值），如果dp[i-1]是正值，同样更新dp[i]=-(dp[i-1]+1)。

参考代码如下：

class Solution {
public:
    int wiggleMaxLength(vector& nums) {
	if (nums.size() <= 1) {
		return nums.size();
	}
	vector dp(nums.size(), 1);
	dp[0] = 0;
	vector position(nums.size());
	for (int i = 0; i < position.size(); i++) {
		position[i] = nums[i];
	}
	int j = INT_MAX;
	bool flag = true;
	for (int i = 1; i < nums.size(); i++) {
		j = i - 1;
		while (j >= 0 && flag) {
			if (dp[j] == 0) {
				if ((position[i] - position[j])>0) {
					dp[i] = 2;
					flag = false;
				}
				else if ((position[i] - position[j])<0) {
					dp[i] = -2;
					flag = false;
				}
			}
			else if (dp[j] > 0 && (nums[i] - position[j])<0) {
				if ((abs(dp[j]) + 1) > abs(dp[i])) {
					dp[i] = -(dp[j] + 1);
					flag = false;
				}
			}
			else if (dp[j] < 0 && (nums[i] - position[j])>0) {
				if ((abs(dp[j]) + 1) > abs(dp[i])) {
					dp[i] = (-dp[j] + 1);
					flag = false;
				}
			}
			j--;
		}
		flag = true;
	}
	return abs(dp[nums.size() - 1]);
    }
};

思路2：这道题可以用贪心算法把时间复杂度优化到O(n)，我们不用去维护一个一维数组dp，因为我们发现每次更新dp[i]一定是更新上一个dp[j](0<=j

class Solution {
public:
    int wiggleMaxLength(vector& nums) {
	if (nums.size() <= 1) {
		return nums.size();
	}
	int p = 1;             
	int q = 1;
	for (int i = 1; i < nums.size(); i++) {
		if (nums[i] > nums[i - 1]) {
			p = max(p, q + 1);         //如果nums[i]是上升元素，那么它的更新一定是保持上一个情况不变（不加自身）和前一个下降元素+1中取最大值
		}
		else if(nums[i] < nums[i - 1]){
			q = max(q, p + 1);         //如果nums[i]是下降元素，那么它的更新一定是保持前一个元素不变（不加自身）和前一个上升元素+1中取最大值

		}
	}
	return max(p, q);
    }
};

可以看到代码简洁了很多，时间复杂度也降到了O(n)