java数据结构与算法刷题目录（剑指Offer、LeetCode、ACM）-----主目录-----持续更新(进不去说明我没写完)：https://blog.csdn.net/grd_java/article/details/123063846

1. 贪心

解题思路：时间复杂度O($n$)，空间复杂度O($1$)

1. 将序列想象成一座山峰，这个山峰由石块构成，我们爬这作山峰，可以前进，所以对我们来说，只有前面的石块和后面的石块。
2. 对我们来说，我们的路线就会有上坡（前面的石块高度（海拔）>后面的石块），下坡（前面的石块海拔<后面的石块），平坡（每块石头的海拔都一样）
3. 题目就是让我们统计，只保留上下坡的情况下，上坡和下坡依次摆动，共摆动了几次

题目特殊要求：

1. 只要有一块石头，就可以算一个坡。例如整座山就一块石头[1],那么就算一个摆动。因为爬上这块石头，算上坡，爬下这块石头，算下坡
2. 有2块石头，但是构成的是平坡，那么只算一个摆动。例如[1,1]，两个石头大小一样。爬上第一块石头算上坡，从第一块到第二块石头，只是直走，没有爬坡。然后从第二块石头下去，算下坡。依然是一个上坡，一个下坡，构成一个摆动。
3. 有两块石头，但是构成的不是平坡，那么算2个摆动。例如[1,2]. 题目要求的。爬上第一块石块算一个摆动，爬下最后一块石头也算一个摆动。
4. 上坡+平坡+上坡，或者下坡+平坡+下坡，属于没换坡，例如[1,2,2,3],只有两个摆动。爬上1算一个摆动，然后1-2是上坡，2-2是平坡，2-3还是上坡，没有坡度变化，都不算坡。最后爬下最后一块石头3，算一个坡。最终共两个坡。

代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) return n;//元素小于2个，就只有n个摆动
        int prevdiff = nums[1] - nums[0];//记录当前坡上的差值，是上坡还是下坡，这里不记录平坡
        int ret = prevdiff != 0 ? 2 : 1;//如果是平坡，就只有1个摆动，如果是上坡或者下坡就有2个摆动（题目规定）
        for (int i = 2; i < n; i++) {//之后还有坡，就继续统计
            int diff = nums[i] - nums[i - 1];//看看当前是什么坡,上坡，还是下坡，还是平坡
            //如果是平坡，下次变坡后，必须通过prevdiff来获取，平坡之前是什么坡
            //如果变坡后，和平坡之前不同，才能称为换坡了，否则还是没有换坡，也就不是摆动
            if ((diff > 0 && prevdiff <= 0) || (diff < 0 && prevdiff >= 0)) {//如果换坡了（上坡变下坡，或者下坡变上坡）
                ret++;//换坡了，摆动+1
                prevdiff = diff;//换坡后，prevdiff变成这个坡的坡度（上坡还是下坡）。以方便寻找下一个不同的坡度
            }
        }
        return ret;//将换坡次数返回
    }
}

2. 动态规划

解题思路：时间复杂度O($n$)，空间复杂度O($n$)

用动态规划来实现上面贪心的思想

动态规划5步曲

1. DP数组及下标含义

1. 我们要求出的是到当前石头为止，坡度上下变化的次数。显然dp数组中存储的是坡度摆动次数。要求出谁的？显然是求出，从起始石头到当前石头的。那么下标就是代表当前是哪块石头。但是如何知道前一块是上坡还是下坡呢？我们可以创建两个数组，一个是当前石头上坡时候用，一个下坡时候用。很显然，需要一个下标，两个数组。

2. 递推公式:dp[]和down[]数组分别用于上坡和下坡

1. 只要有石头，那么摆动就有1，具体请参考上面的"法一：贪心"的解析。所以up[0] = down[0] = 1.
2. 从第二块石块开始后面的每一块石头,记为第i块石头。
3. 我们分别获取up[i-1],down[i-1]，它们保存到前一块石头的路径摆动次数。则他俩里面大的那个，一定是上块石头的坡度。因为上一块石头，如果是上坡就放入up,下坡就放入down
4. 如果第i块石块，是上坡，我们获取Math.max(up[i-1],down[i-1]),如果结果是down[i-1]更大，说明上一块是下坡，而第i块是上坡。则摆动+1.
5. 依次类推，得到公式：

1. i是上坡，up[i] = Math.max(up[i-1],down[i-1]+1). down[i] = down[i-1]. 其中down[i] = down[i-1]是因为i石块不是下坡，用不着down，但是down[i]下次会用到，所以将[i-1]的值给[i]

Math.max(up,down)获取的是i-1的坡度，down[i-1]+1,是如果i-1是下坡，那么到i位置的路径摆动次数是i-1的摆动次数+1。因为如果i-1是下坡，而现在i是上坡，down[i-1]就是到前一块路径的摆动次数，i是上坡，要增加一次摆动。等价于如下代码:

int num = Math.max(up[i-1],down[i-1]);
boolean flag = true;//上一个石头默认是上坡
if(num  == down[i-1]) flag = false;//上一个石头是下坡
if(flag) up[i] = up[i-1];//上一个也是上坡，那么摆动不变
else up[i] = down[i-1]+1;//上一个是下坡，那么摆动+1

2. i是下坡，up[i] = up[i-1]; down[i] = Math.max(up[i-1]+1),down[i-1]
3. i是平坡，up[i] = up[i-1];down[i] = down[i-1];

3. dp数组初始化

4. 数组遍历顺序:一维数组，无需考虑

代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        //和贪心一样
        int n = nums.length;
        if (n < 2) return n;
        //dp数组表示，当前石块i，如果是上坡的，就放入up中，如果是下坡的，就放入down中，然后计算到这块石头为止的摆动
        //up表示上坡，down表示下坡。dp数组的下标表示，第几块石头
        //例如up[1],就是第一块石头如果是上坡，到它为止的路径，它的最大摆动是多少
        //down[3]就是第3块石头，如果是下坡，到它为止的路径，最大摆动是多少
        /**则dp数组的值保存的就是 到第i块石块，摆动的数量 */
        int[] up = new int[n];
        int[] down = new int[n];
        up[0] = down[0] = 1;//有石头就有一个摆动，无论上坡，还是下坡，都算一个摆动。
        for (int i = 1; i < n; i++) {//从第一块石头开始规划坡度
            if (nums[i] > nums[i - 1]) {//如果当前石块是上坡
                //当前石块应该放入上坡UP中，获取前一块石头的信息，前一块如果也是上坡，则摆动数量不变，前一块是下坡，那么摆动+1. 
                //对于我们来说，我们不知道前一块是上坡还是下坡，但是上一块石头的路径摆动，一定放入了dp数组
                //而且一定是最大的，所以up[i-1]和down[i-1]，就是获取前一块石头的最大摆动
                up[i] = Math.max(up[i - 1], down[i - 1] + 1);//必须两个一起获取，因为不知道前一块是上坡还是下坡
                //当前石块i是上坡，无法放入下坡，所以对于down来说，只能抛弃这块石头，那么摆动不变
                down[i] = down[i - 1];//让其继承前一块石头的坡度
            } else if (nums[i] < nums[i - 1]) {//如果当前石块是下坡
                up[i] = up[i - 1];//和上坡没有关系，抛弃这块石头
                //获取前一块石头的信息，如果是上坡，那么摆动+1,如果是下坡，摆动不变。
                down[i] = Math.max(up[i - 1] + 1, down[i - 1]);
            } else {//如果是平坡
                up[i] = up[i - 1];//摆动不变
                down[i] = down[i - 1];//摆动不变
            }
        }
        //到最后一块石头石，我们也不知道最后一块是上坡还是下坡。只知道到它为止的摆动，放入了up[n-1]和down[n-1]
        //而且肯定是大的那个
        return Math.max(up[n - 1], down[n - 1]);
    }
}

3. 优化版动态规划

解题思路：时间复杂度O($n$)，空间复杂度O($1$)

将法二的dp数组优化掉，换成了两个变量
因为法二中，虽然是dp数组，但是我们每次只使用前一个值罢了

代码

1. 基于法二，单纯将数组换成变量

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) return n;
        
        int up = 1, down = 1;//将dp数组，换成两个变量
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {//如果是上坡
                up = Math.max(up, down + 1);//看前一个是不是上坡，不是就摆动+1
            } else if (nums[i] < nums[i - 1]) {//如果是下坡
                down = Math.max(up + 1, down);//上一个是上坡，就摆动+1
            }
        }
        return Math.max(up, down);
    }
}

2. 我们发现，上坡的话，up的值不变，下坡的话，down的值不变.而本次修改up的值后，下次一定是修改down的值。因为我们要找的就是上坡和下坡交替出现，所以根本没必要每次用Math.max()方法

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return n;
        }
        int up = 1, down = 1;//将dp数组，换成两个变量
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {//如果是上坡
                up = down + 1;//看前一个是不是上坡，不是就摆动+1
            } else if (nums[i] < nums[i - 1]) {
                down = up + 1;
            }
        }
        return Math.max(up, down);
    }
}