Leetcode376摆动序列

我觉得这是一道很好的题目，记录一下两种方法，贪心和动态规划。

贪心

对于本题来说，有二种情况

(1) 1,2,2,2,2,4 长度为2

(2) 1,2,2,2,2,1 长度为3

那么可以用变量pre和cur记录一下前后的插值，判断pre和cur是否异号来决定长度的增加。

参考代码：

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        int count = 1;
        int pre = 0;
        int cur = 0;
        for (int i = 0; i < nums.length-1; i++) {
         cur = nums[i+1]-nums[i];
         if((pre<=0&&cur>0)||(pre>=0&&cur<0)){
             count++;
             pre = cur;
         }
        }
        return count;
    }
}

动态规划

用动态规划来做这道题十分巧妙！

很容易可以发现，对于我们当前考虑的这个数，要么是作为山峰（即 numsi > numsi-1），要么是作为山谷（即 numsi < numsi - 1）。

设 dp 状态dpi0，表示考虑前 i 个数，第 i 个数作为山峰的摆动子序列的最长长度

设 dp 状态dpi1，表示考虑前 i 个数，第 i 个数作为山谷的摆动子序列的最长长度

则转移方程为：

dpi0 = max(dpi0, dpj1 + 1)，其中0 < j < i且numsj < numsi，表示将 numsi接到前面某个山谷后面，作为山峰。

dpi1 = max(dpi1, dpj0 + 1)，其中0 < j < i且numsj > numsi，表示将 numsi接到前面某个山峰后面，作为山谷。

初始状态：

由于一个数可以接到前面的某个数后面，也可以以自身为子序列的起点，所以初始状态为：dp00 = dp01 = 1。

参考代码：

class Solution {
    public int wiggleMaxLength(int[] nums) {
        // 0 i 作为波峰的最大长度
        // 1 i 作为波谷的最大长度
        int dp[][] = new int[nums.length][2];

        dp[0][0] = dp[0][1] = 1;
        for (int i = 1; i < nums.length; i++){
            //i 自己可以成为波峰或者波谷
            dp[i][0] = dp[i][1] = 1;

            for (int j = 0; j < i; j++){
                if (nums[j] > nums[i]){
                    // i 是波谷
                    dp[i][1] = Math.max(dp[i][1], dp[j][0] + 1);
                }
                if (nums[j] < nums[i]){
                    // i 是波峰
                    dp[i][0] = Math.max(dp[i][0], dp[j][1] + 1);
                }
            }
        }

        return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
    }
}