【贪心算法】leetcode376.摆动序列

题目描述（传送门）

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

例如， [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

思考

首先[1,17,5,10,13,15,10,5,16,8]，整体不是摇摆序列：
观察该序列前6位：[1,17,5,10,13,15],后边4个位上升部分；其中他有三个子序列是摇摆序列：

[1,17,5,10,5,16,8]
[1,17,5,13,5,16,8]
[1,17,5,15,5,16,8]

在不清楚原始序列的7位是什莫的情况下，只看前六位，摇摆子序列的第四位开始从10，13，15中选择一个数。

我们就应尽可能选择最大的数。

贪心规律

当序列有一段连续的递增或者递减时，为形成摇摆子序列，我们只需要保留这段连续的递增或递减的首尾元素，这样更可能使得尾部的后一个元素成为摇摆子序列的下一个元素。

解题思路&代码实现

在这里使用状态机的思想，这也是第一次把状态机思想用在算法题上，在之前FPGA学习中设计过状态机，所以也就不是很陌生。有兴趣可以看看去年写的博客：如何写好状态机？跑马灯/流水灯Verilog HDL实现

首先我们来看一下状态转移图：
开始我们定义三个状态：
final int BEGIN = 0;
final int UP = 1;
final int DOWN = 2;

在状态转换时max_length++也就是在拐点处。

图中看出，遍历过程中相当于把4，5，7三个点删除了。最后保留了6，8相当于选取了局部最大/最小点，满足贪心。

package com.wenhui.lession3;

/**
 * @ClassName leetcode376
 * @Description ：TODO
 * @Author Josvin
 * @Date 2021/02/03/17:09
 */
public class leetcode376 {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length < 2) {
            return nums.length;
        }
        final int BEGIN = 0;
        final int UP = 1;
        final int DOWN = 2;
        int START = BEGIN;
        int max_length = 1;// 摇摆序列最大长度最小为1
        for (int i = 0; i < nums.length - 1; i++) {
            switch (START) {
                case BEGIN:
                    if (nums[i] < nums[i + 1]) {// 上升趋势
                        START = UP;
                        max_length++;
                    } else if (nums[i] > nums[i + 1]) {// 下降趋势
                        START = DOWN;
                        max_length++;
                    }
                    // 相等继续原地打转
                    break;
                case UP:
                    // 上升趋势进来的，下一个状态还是上升，则不加，状态不变
                    if (nums[i] < nums[i + 1]) {
                        START = UP;
                        // UP->DOWN
                    } else if (nums[i] > nums[i + 1]) {

                        START = DOWN;
                        max_length++;
                    }
                    // UP—>UP
                    break;
                case DOWN:
                    // DOWN->UP
                    if (nums[i] < nums[i + 1]) {
                        START = UP;
                        max_length++;
                        //DOWN->DOWN
                    } else if (nums[i] > nums[i + 1]) {
                        START = DOWN;
                    }
                    break;

            }
        }
        return max_length;
    }
}