力扣 376. 摆动序列 精讲

力扣 376. 摆动序列 精讲

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

• 例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

• 相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。

示例 1：

输入：nums = [1,7,4,9,2,5]
输出：6
解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。

示例 2：

输入：nums = [1,17,5,10,13,15,10,5,16,8]
输出：7
解释：这个序列包含几个长度为 7 摆动序列。
其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。

示例 3：

输入：nums = [1,2,3,4,5,6,7,8,9]
输出：2

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000

方法一：贪心算法

可以理解为我只要这个数组中的波峰和波谷 即为总长度 且这俩交替出现就行 可以贪心的去省略中间上升到波峰的趋势的那些数字，也可以贪心的去省略下降到波谷的趋势。

具体的可以看注释，还看不懂就看这个。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length<=1){
            return nums.length;
        }
        //贪心算法
        //结果是初始的时候就算上了最左侧的  然后自增的时候就是俩了
        int res = 1;
        //记录上一次加入到序列中的节点的和后一个节点的差值
        int pre = 0;
        //记录当前节点和后一个节点的差值
        int cur=0;
        for(int i=0;i<nums.length-1;i++){
            //去看每一个峰值
            //就算满足了条件  也会一直更新 即找到局部最大或最小的去更新
            cur = nums[i+1]-nums[i];
            //每次局部峰值只会++一次 你可以理解为峰值(pre和cur正负不一致)就记录
            if(cur>0&&pre<=0||cur<0&&pre>=0){
                res++;
                pre=cur;
            }
        }  
        return res;
    }
}

方法二：dp 时间O(N²) 空间O(N)

具体的可以看注释，还看不懂就看这个。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n=nums.length;
        if(n<=1){
            return n;
        }
        //dp算法
        //关键就在于从前面的序列转移过来的方式
        //而官方题解给出了O(n)的方式 感觉证明我不太理解
        //这里代码随想录只给出了O(N方)的dp


        //定义一个最后结尾为峰(即最后两个数是上升的序列)的dp数组
        //up[i]代表从0~i组成的最长的子序列长度且序列最后两个数是递增的
        int[] up = new int[n];

        //定义一个最后结尾为谷(即最后两个数是下降的序列)的dp数组
        //down[i]代表从0~i组成的最长的子序列长度且序列最后两个数是递减的
        int[] down = new int[n];

        //初始值都是1
        up[0]=1;
        down[0]=1;

        //遍历nums
        for(int i=1;i<n;i++){
            //对于每一个值都要和前面所有的值比较  得到最大长度的可能性
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    //当当前值大于序列中的值时 长度只可能从down[j]中增加
                    //即将nums[i]作为峰跟在nums[j]这个谷后面
                    up[i] = Math.max(up[i],down[j]+1);
                    //我虽然没你大 但是我作为个更长的序列 我应当保存最大的值
                    //因此这个更新没啥意义。。。
                    //从下面就更新好了
                    // down[i] = Math.max(down[i],down[j]);
                }else if(nums[i]<nums[j]){
                    //当当前值小于序列中的值时 长度只可能从up[j]中增加
                    //即将nums[i]作为谷跟在nums[j]这个峰后面
                    down[i] = Math.max(down[i],up[j]+1);
                    //我虽然没你大 但是我作为个更长的序列 我应当保存最大的值
                    //因此这个更新没啥意义。。。
                    //从上面就更新好了
                    // up[i] = Math.max(up[i],up[j]);
                }else{
                    up[i] = Math.max(up[i],up[j]);
                    down[i] = Math.max(down[i],down[j]);
                }
            }
        }        
        //因为最后一个值要么是波峰 要么是波谷 一定在最后一个位置上
        return Math.max(up[n-1],down[n-1]);
    }
}

方法三：dp 时间O(N) 空间O(N)

注意 dp数组的定义变了哦~

具体的可以看注释，还看不懂就看这个。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n=nums.length;
        if(n<=1){
            return n;
        }
        //dp算法
        //而官方题解给出了O(n)的方式 差不多看懂了
        //关键在于当只通过和前一个值进行比较 就能得出前面一定是递减到一个谷这个结论


        //up[i]代表从0~i中某一个数为结尾的最长摆动序列的长度 且最后为递增的两个数
        int[] up = new int[n];

        //down[i]代表从0~i中某一个数为结尾的最长摆动序列的长度 且最后为递减的两个
        int[] down = new int[n];

        //初始值都是1
        up[0]=1;
        down[0]=1;

        //遍历nums
        for(int i=1;i<n;i++){
            //对于每一个值都要和前面所有的值比较  
            if(nums[i]<nums[i-1]){
                //当当前值小于前一个值时
                //对于up[i] 结尾处是递增的 而当前值小于最高处 因此0~i中的最长上摆序列依旧不会变 因为对于谷而言 i-1和i都一样(up[i-1]一致)
                up[i] = up[i-1];
                //对于down[i] 因为当前值小于前一个 此处一定是一个下降的趋势 前面一定有一个峰 那么我有可能是已经在递减的路上了(和down[i-1]一致 那么这种时候down[i-1]一定是最长的) 也有可能是第一个递减的数字(从up[i-1]+1来  代表从上摆序列到下摆序列的过程)
                down[i] = Math.max(down[i-1],up[i-1]+1);
            }else if((nums[i]>nums[i-1])){
                //当当前值大于前一个值时 
                //对于up[i] 结尾处是递增的 而当前值大于最高处因此可以从up[i-1]来，也可以从down[i-1]+1来 因为我大于前面一个值  因此前面的数组一定是一个递增的过程，那么前面第一个一定是谷而不是峰，那么我可以从前面的谷+1 从下摆转到上摆序列来 
                up[i] = Math.max(up[i-1],down[i-1]+1);
                //对于down[i] 我大于前一个值 那么对于总体的0~i而言 我肯定去nums[i-1]位置上的值更好  因为我要的是下摆序列 结尾一定要下降的 因此还是down[i-1]
                down[i]=down[i-1];
            }else{
                //相等的时候  直接和上一个一样
                up[i] = up[i-1];
                down[i] = down[i-1];
            }
        }        
        //最长序列一定在两个数组最后
        return Math.max(up[n-1],down[n-1]);
    }
}

方法四：dp 时间O(N) 空间O(1)

空间优化 没啥技术含量

具体的可以看注释，还看不懂就看这个。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n=nums.length;
        if(n<=1){
            return n;
        }
        //dp算法
        //优化了空间  
        //如果你又看到这个题了 一定要看看上个版本的详细注释
        //注释写的很清楚了捏 这个是时间O(n) 空间O(1)的算法
        //上个是时间O(n) 空间O(n)
        //代码随想录的是时间O(n方) 空间O(n)
        int up = 1;
        int down = 1;
        for(int i=1;i<n;i++){
            if(nums[i]<nums[i-1]){
                down = Math.max(down,up+1);
            }else if((nums[i]>nums[i-1])){
                up = Math.max(up,down+1);
            }else{
            }
        }        
        //最长序列一定在两个数组最后
        return Math.max(up,down);
    }
}

方法五：dp 究极优化

来自数学的优化。。。每次出现趋势变动的时候就会+1 那么不用max函数了就

具体的可以看注释，还看不懂就看这个。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n=nums.length;
        if(n<=1){
            return n;
        }
        //dp算法
        //优化了空间  
        //如果你又看到这个题了 一定要看看上个版本的详细注释
        //注释写的很清楚了捏 这个是时间O(n) 空间O(1)的算法
        //上个是时间O(n) 空间O(n)
        //代码随想录的是时间O(n方) 空间O(n)
        int up = 1;
        int down = 1;
        for(int i=1;i<n;i++){
            if(nums[i]<nums[i-1]){
                down = up+1;
            }else if((nums[i]>nums[i-1])){
                up = down+1;
            }
        }        
        //最长序列一定在两个数组最后
        return Math.max(up,down);
    }
}