LeetCode——376.摆动序列

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

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

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

示例 1:

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

示例 2:

输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。

示例 3:

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

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/wiggle-subsequence

动态规划

我们维护两个dp数组p和q，其中

p[i]表示到i位置时首差值为正的摆动子序列的最大长度，

q[i]表示到i位置时首差值为负的摆动子序列的最大长度。

我们从i=1开始遍历数组，然后对于每个遍历到的数字，再从开头位置遍历到这个数字，

然后比较nums[i]和nums[j]，分别更新对应的位置，参见代码如下：

C++

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.empty()) return 0;
        vector<int> p(nums.size(), 1);
        vector<int> q(nums.size(), 1);
        for (int i = 1; i < nums.size(); ++i) {
            for (int j = 0; j < i; ++j) {
                if      (nums[i] > nums[j]) p[i] = max(p[i], q[j] + 1);
                else if (nums[i] < nums[j]) q[i] = max(q[i], p[j] + 1);
            }
        }
        return max(p.back(), q.back());
    }
};

java

public class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length < 2)
            return nums.length;
        int[] p = new int[nums.length];
        int[] q = new int[nums.length];
        for (int i = 1; i < nums.length; i++) {
            for(int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    p[i] = Math.max(p[i],q[j] + 1);
                } else if (nums[i] < nums[j]) {
                    q[i] = Math.max(q[i],p[j] + 1);
                }
            }
        }
        return 1 + Math.max(q[nums.length - 1], p[nums.length - 1]);
    }
}

java优化

public class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length < 2)
            return nums.length;
        int[] p = new int[nums.length];
        int[] q = new int[nums.length];
        p[0] = q[0] = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                p[i] = q[i - 1] + 1;
                q[i] = q[i - 1];
            } else if (nums[i] < nums[i - 1]) {
                q[i] = p[i - 1] + 1;
                p[i] = p[i - 1];
            } else {
                q[i] = q[i - 1];
                p[i] = p[i - 1];
            }
        }
        return Math.max(q[nums.length - 1], p[nums.length - 1]);
    }
}

Python

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if not nums:
            return 0
        res = []
        dp = [[1 for i in range(2)] for j in range(len(nums))]
        res.append(dp[0][0])
        res.append(dp[0][1])
        for i in range(1,len(nums)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i][1] = max(dp[i][1],dp[j][0]+1)
                elif nums[i] < nums[j]:
                    dp[i][0] = max(dp[i][0],dp[j][1]+1)
                else:               #若nums[i]=nums[j]，此时nums[i]不可能加在nums[j]后面
                    continue
            res.append(dp[i][0])
            res.append(dp[i][1])
        return max(res)

# dp[i][0]表示以nums[i]结尾且当前位置为降序的最长摆动序列，
# dp[i][1]表示以nums[i]结尾且当前位置为升序的最长摆动序列

贪心算法

这里我们不在维护两个dp数组，而是维护两个变量p和q，然后遍历数组，

如果当前数字比前一个数字大，则p=q+1，如果比前一个数字小，则q=p+1，

最后取p和q中的较大值跟n比较，取较小的那个，参见代码如下：

C++

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int p = 1, q = 1, n = nums.size();
        for (int i = 1; i < n; ++i) {
            if (nums[i] > nums[i - 1]) p = q + 1;
            else if (nums[i] < nums[i - 1]) q = p + 1;
        }
        return min(n, max(p, q));
    }
};

Java

public class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length < 2) return nums.length;
        int q = 1, p = 1;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) p = q + 1;
            else if (nums[i] < nums[i - 1]) q = p + 1;
        }
        return Math.max(q, p);
    }
}