PDF文档下载：LeetCode-贪心算法-java
参考：代码随想录

题目分类大纲如下：

贪心算法理论基础

什么是贪心？

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

贪心的套路（什么时候用贪心）

贪心算法并没有固定的套路，说白了就是常识性推导加上举反例。靠自己手动模拟，如果模拟可行，就可以试一试贪心策略，如果不可行，可能需要动态规划。

如何验证可不可以用贪心算法呢？最好用的策略就是举反例，如果想不到反例，那么就试一试贪心吧。

贪心一般解题步骤

贪心算法一般分为如下四步：

• 将问题分解为若干个子问题

• 找出适合的贪心策略

• 求解每一个子问题的最优解

• 将局部最优解堆叠成全局最优解

其实这个分的有点细了，真正做题的时候很难分出这么详细的解题步骤，可能就是因为贪心的题目往往还和其他方面的知识混在一起。

基础题目

1、455.分发饼干

参考：LeetCode-455. 分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是满足尽可能多的孩子，并输出这个最大数值。

示例 1:

输入: g = [1,2,3], s = [1,1]
输出: 1
解释: 
你有三个孩子和两块小饼干，3 个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是 1，你只能让胃口值是 1 的孩子满足。
所以你应该输出 1。

示例 2:

输入: g = [1,2], s = [1,2,3]
输出: 2
解释: 
你有两个孩子和三块小饼干，2 个孩子的胃口值分别是 1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出 2。

提示：

• 1 <= g.length <= 3 * 10^4

• 0 <= s.length <= 3 * 10^4

• 1 <= g[i], s[j] <= 2^31 - 1

贪心-优先小饼干

为了尽可能满足最多数量的孩子，从贪心的角度考虑，应该按照孩子的胃口从小到大的顺序依次满足每个孩子，且对于每个孩子，应该选择可以满足这个孩子的胃口且尺寸最小的饼干

这里的局部最优就是小饼干喂给胃口小的，充分利用小饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

• 可以尝试使用贪心策略，先将饼干数组和小孩数组排序。

• 然后从前向后遍历饼干数组，用小饼干优先满足胃口小的，并统计满足小孩数量。

java

import java.util.Arrays;
public class LeetCode_455 {
    public static void main(String[] args) {
        int[] g = {1,2};
        int[] s = {1,2,3};
        System.out.println(findContentChildren(g, s));
    }


    public static int findContentChildren(int[] g, int[] s) {
        int res = 0;
        int n = g.length;
        Arrays.sort(g);
        Arrays.sort(s);
        // 遍历饼干，优先使用小的饼干喂饱小胃口的学生
        for (int i : s) {
            if (res < n && i >= g[res]) {
                res++;
            }
        }
        return res;
    }
}

python

def findContentChildren(g: list, s: list) -> int:
    g.sort()
    s.sort()
    res = 0
    for i in range(len(s)):
        if res <len(g) and s[i] >= g[res]:  #小饼干先喂饱小胃口
            res += 1
    return res

贪心-优先大饼干

为了了满足更多的小孩，就不要造成饼干尺寸的浪费。大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子，那么就应该优先满足胃口大的。

这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

• 可以尝试使用贪心策略，先将饼干数组和小孩数组排序。

• 然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。

如图：

这个例子可以看出饼干9只有喂给胃口为7的小孩，这样才是整体最优解，并想不出反例，那么就可以撸代码了。

java

import java.util.Arrays;
public class LeetCode_455_2_greedy {
    public static void main(String[] args) {
        int[] g = {1, 2};
        int[] s = {1, 2, 3};
        System.out.println(findContentChildren(g, s));
    }


    public static int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int index = s.length - 1;
        int res = 0;
        int n = g.length;
        // 大尺寸饼干优先满足大胃口的学生
        for (int i = n - 1; i >= 0; i--) {
            if (index >= 0 && g[i] <= s[index]) {
                index--;
                res++;
            }
        }
        return res;
    }
}

python

def findContentChildren(g: list, s: list) -> int:
    g.sort()
    s.sort()
    start, count = len(s) - 1, 0
    for index in range(len(g) - 1, -1, -1): # 先喂饱大胃口
        if start >= 0 and g[index] <= s[start]: 
            start -= 1
            count += 1
    return count

2、860.柠檬水找零

参考：LeetCode-860. 柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：

输入：bills = [5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

提示：

• 1 <= bills.length <= 10^5

• bills[i] 不是 5 就是 10 或是 20

贪心

只需要维护三种金额的数量，5，10和20。

有如下三种情况：

• 情况一：账单是5，直接收下。

• 情况二：账单是10，消耗一个5，增加一个10

• 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

此时大家就发现 情况一，情况二，都是固定策略，都不用我们来做分析了，而唯一不确定的其实在情况三。而情况三逻辑也不复杂甚至感觉纯模拟就可以了，其实情况三这里是有贪心的。账单是20的情况，为什么要优先消耗一个10和一个5呢？

因为美元10只能给账单20找零，而美元5可以给账单10和账单20找零，美元5更万能！

所以

• 局部最优：遇到账单20，优先消耗美元10，完成本次找零。

• 全局最优：完成全部账单的找零。

局部最优可以推出全局最优，并找不出反例，那么就试试贪心算法！

java

public class LemonadeChange {
    public static void main(String[] args) {
        int[] bills = {5, 5, 5, 10, 20};
        System.out.println(lemonadeChange(bills));
    }
    
    public static boolean lemonadeChange(int[] bills) {
        int five = 0, ten = 0;
        for (int bill : bills) {
            if (bill == 5) {
                five++;
            } else if (bill == 10) {
                if (five == 0) {
                    return false;
                }
                five--;
                ten++;
            } else {
                // 给20找零优先用10块的
                if (five > 0 && ten > 0) {
                    five--;
                    ten--;
                } else if (five >= 3) {
                    five -= 3;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}

复杂度分析

• 时间复杂度：O(N)，其中 N 是 bills 的长度。

• 空间复杂度：O(1)。

python

def lemonadeChange(bills: list) -> bool:
    # 记录每种币种个数
    five, ten, twenty = 0, 0, 0
    # 遍历
    for bill in bills:
        if bill == 5:  # 5美元
            five += 1
        elif bill == 10:  # 10美元
            if five < 1: return False
            five -= 1
            ten += 1
        else:  # 20美元
            # 20美元优先使用10美元兑换
            if ten > 0 and five > 0:
                ten -= 1
                five -= 1
                twenty += 1
            # 没有10美元采用3个5美元兑换
            elif five > 2:
                five -= 3
                twenty += 1
            else:
                return False
    return True

3、561.数组拆分

参考：LeetCode-561. 数组拆分

给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), …, (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

返回该 最大总和 。

示例 1：

输入：nums = [1,4,3,2]
输出：4
解释：所有可能的分法（忽略元素顺序）为：
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
所以最大总和为 4

示例 2：

输入：nums = [6,2,6,5,1,2]
输出：9
解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

提示：

• 1 <= n <= 10^4

• nums.length == 2 * n

• -10^4 <= nums[i] <= 10^4

排序+贪心

要想每对数最小值的总和最大，就得使每对数的最小值尽可能大。只有让较大的数与较大的数一起组合，较小的数与较小的数一起结合，才能才能使总和最大。

• 对 nums 进行排序。

• 将相邻两个元素的最小值进行相加，即得到结果

import java.util.Arrays;
public class LeetCode_561_greedy {
    public static void main(String[] args) {
        int[] nums = {1, 4, 3, 2};
        System.out.println(arrayPairSum(nums));
    }


    public static int arrayPairSum(int[] nums) {
        // 数组升序排序
        Arrays.sort(nums);


        // 数组两两一组，每一组取第一个值累加
        int n = nums.length;
        int res = 0;
        for (int i = 0; i < n; i += 2) {
            res += nums[i];
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(n×log⁡n)

• 空间复杂度：O(1)

4、1710.卡车上的最大单元数

参考：LeetCode-1710. 卡车上的最大单元数

请你将一些箱子装在 一辆卡车 上。给你一个二维数组 boxTypes ，其中 boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi] ：

• numberOfBoxesi 是类型 i 的箱子的数量。

• numberOfUnitsPerBoxi 是类型 i 每个箱子可以装载的单元数量。

整数 truckSize 表示卡车上可以装载 箱子 的 最大数量 。只要箱子数量不超过 truckSize ，你就可以选择任意箱子装到卡车上。

返回卡车可以装载 单元 的 最大 总数。

示例 1：

输入：boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4
输出：8
解释：箱子的情况如下：
- 1 个第一类的箱子，里面含 3 个单元。
- 2 个第二类的箱子，每个里面含 2 个单元。
- 3 个第三类的箱子，每个里面含 1 个单元。
可以选择第一类和第二类的所有箱子，以及第三类的一个箱子。
单元总数 = (1 * 3) + (2 * 2) + (1 * 1) = 8

示例 2：

输入：boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10
输出：91

提示：

• 1 <= boxTypes.length <= 1000

• 1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000

• 1 <= truckSize <= 10^6

贪心

一辆卡车上可以装载箱子的最大数量是固定的（truckSize），那么如果想要使卡车上装载的单元数量最大，就应该优先选取装载单元数量多的箱子。

所以，从贪心算法的角度来考虑，我们应该按照每个箱子可以装载的单元数量对数组 boxTypes

boxTypes 从大到小排序。然后优先选取装载单元数量多的箱子。步骤如下：

• 对数组 boxTypes 按照每个箱子可以装载的单元数量从大到小排序。使用变量 res 记录卡车可以装载的最大单元数量。

• 遍历数组 boxTypes，对于当前种类的箱子 box：

  • 如果 truckSize>box[0]，说明当前种类箱子可以全部装载。则答案数量加上该种箱子的单元总数，即 box[0]×box[1]，并且最大数量 truckSize 减去装载的箱子数。

  • 如果 truckSize≤box[0]，说明当前种类箱子只能部分装载。则答案数量加上truckSize×box[1]，并跳出循环。

• 最后返回答案 res

java

import java.util.Arrays;
public class LeetCode_1710_greedy {
    public static void main(String[] args) {
        int[][] boxTypes = {{1, 3}, {2, 2}, {3, 1}};
        int truckSize = 4;
        System.out.println(maximumUnits(boxTypes, truckSize));
    }


    public static int maximumUnits(int[][] boxTypes, int truckSize) {
        // 按照每一类箱子最大可装载单元数降序排序
        Arrays.sort(boxTypes, (boxType1, boxType2) -> (boxType2[1] - boxType1[1]));


        // 从左到右遍历，优先装载单元较大的箱子
        int res = 0;
        for (int[] boxType : boxTypes) {
            if (boxType[0] < truckSize) {
                res += boxType[0] * boxType[1];
                truckSize -= boxType[0];
            } else {
                res += truckSize * boxType[1];
                break;
            }
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(nlogn)，其中 n 是 boxTypes 的长度。排序需要 O(nlogn) 的时间。

• 空间复杂度：O(logn)，其中 n 是 boxTypes 的长度。排序需要 O(logn) 的递归调用栈空间。

5、1217.玩筹码

参考：LeetCode-1217. 玩筹码

有 n 个筹码。第 i 个筹码的位置是 position[i] 。

我们需要把所有筹码移到同一个位置。在一步中，我们可以将第 i 个筹码的位置从 position[i] 改变为:

• position[i] + 2 或 position[i] - 2 ，此时 cost = 0

• position[i] + 1 或 position[i] - 1 ，此时 cost = 1

返回将所有筹码移动到同一位置上所需要的 最小代价 。

示例 1：

输入：position = [1,2,3]
输出：1
解释：第一步:将位置3的筹码移动到位置1，成本为0。
第二步:将位置2的筹码移动到位置1，成本= 1。
总成本是1。

示例 2：

输入：position = [2,2,2,3,3]
输出：2
解释：我们可以把位置3的两个筹码移到位置2。每一步的成本为1。总成本= 2。

示例 3:

输入：position = [1,1000000000]
输出：1

提示：

• 1 <= position.length <= 100

• 1 <= position[i] <= 10^9

贪心

题目中移动偶数位长度是不需要代价的，所以奇数位移动到奇数位不需要代价，偶数位移动到偶数位也不需要代价。

我们可以想将所有偶数位都移动到下标为 0 的位置，奇数位都移动到下标为 1 的位置。这样，所有的奇数位、偶数位上的人都到相同或相邻位置了。我们只需要统计一下奇数位和偶数位的数字个数。将少的数移动到多的数上边就是最小代价。

则这道题就可以通过以下步骤求解：

• 遍历数组，统计数组中奇数个数和偶数个数。

• 返回奇数个数和偶数个数中较小的数即为答案

java

public class LeetCode_1217_greedy {
    public static void main(String[] args) {
        int[] position = {1, 2, 3};
        System.out.println(minCostToMoveChips(position));
    }


    public static int minCostToMoveChips(int[] position) {
        // 分别统计奇数和偶数索引上的筹码数量(奇数/偶数索引之间相互移动无成本)
        int odd = 0;
        int even = 0;
        for (int index : position) {
            if (index % 2 == 0) {
                even++;
            } else {
                odd++;
            }
        }


        // 将较小的（奇数和/偶数和）移动到较大的上成本最低
        return Math.min(odd, even);
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组 position 的长度，只对数组进行了一次遍历。

• 空间复杂度：O(1)，仅使用常数变量。

字符串贪心

6、921.使括号有效的最少添加

参考：LeetCode-921. 使括号有效的最少添加

只有满足下面几点之一，括号字符串才是有效的：

• 它是一个空字符串，或者

• 它可以被写成 AB （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者

• 它可以被写作 (A)，其中 A 是有效字符串。

给定一个括号字符串 s ，在每一次操作中，你都可以在字符串的任何位置插入一个括号

• 例如，如果 s = “()))” ，你可以插入一个开始括号为 “(()))” 或结束括号为 “())))” 。

返回 为使结果字符串 s 有效而必须添加的最少括号数。

示例 1：

输入：s = "())"
输出：1

示例 2：

输入：s = "((("
输出：3

提示：

• 1 <= s.length <= 1000

• s 只包含 ‘(’ 和 ‘)’ 字符。

栈

这道题是括号匹配的题目。每个左括号必须对应一个右括号，而且左括号必须在对应的右括号之前。对于括号匹配的题目，常用的做法是使用栈进行匹配，栈具有后进先出的特点，因此可以保证右括号和最近的左括号进行匹配

java

import java.util.ArrayDeque;
import java.util.Deque;
public class LeetCode_921_greedy {
    public static void main(String[] args) {
        String s = "()))((";
        System.out.println(minAddToMakeValid(s));
    }


    public static int minAddToMakeValid(String s) {
        // 利用栈来匹配左右有效括号，统计匹配不到的数量就是需要添加的括号数
        Deque<Character> stack = new ArrayDeque<>();
        int n = s.length();
        for (int i = 0; i < n; i++) {
            if (!stack.isEmpty() && (stack.peek() == '(' && s.charAt(i) == ')')) {
                stack.pop();
                continue;
            }
            stack.push(s.charAt(i));
        }
        // 栈内没有正确匹配的括号数就是需要添加的对应括号数目
        return stack.size();
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是字符串的长度。每个元素最多需要进出栈各一次。

• 空间复杂度：O(n)，栈只需要常数空间。

贪心

这道题可以使用计数代替栈，进行匹配时每次都取距离当前位置最近的括号，就可以确保平衡。从左到右遍历字符串，在遍历过程中维护左括号的个数以及添加次数。

如果遇到左括号，则将左括号的个数加 1。

如果遇到右括号，则需要和前面的左括号进行匹配，具体做法如下：

• 如果左括号的个数大于 0，则前面有左括号可以匹配，因此将左括号的个数减 1，表示有一个左括号和当前右括号匹配；

• 如果左括号的个数等于 0，则前面没有左括号可以匹配，需要添加一个左括号才能匹配，因此将添加次数加 1。

遍历结束后，需要检查左括号的个数是否为 0。如果不为 0，则说明还有剩下的左括号没有匹配，对于每个剩下的左括号都需要添加一个右括号才能匹配，此时需要添加的右括号个数为剩下的左括号个数，将需要添加的右括号个数加到添加次数。

无论是哪种添加的情况，都是在遇到括号无法进行匹配的情况下才进行添加，因此上述做法得到的添加次数是最少的。

java

public class LeetCode_921_greedy_2 {
    public static void main(String[] args) {
        String s = "()))((";
        System.out.println(minAddToMakeValid(s));
    }


    public static int minAddToMakeValid(String s) {
        int res = 0;
        int leftCount = 0;
        // 从左向右遍历遇到左括号则统计数量，遇到右括号则使用最近的左括号匹配，没有则需要添加res+1
        for (char ch : s.toCharArray()) {
            if (ch == '(') {
                leftCount++;
            } else {
                if (leftCount > 0) {
                    leftCount--;
                } else {
                    res++;
                }
            }
        }


        // 遍历结束查看左括号数量，左括号数量>0则没有被匹配，需要添加对应数量右括号来匹配
        return res + leftCount;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是字符串的长度。遍历字符串一次。

• 空间复杂度：O(1)。只需要维护常量的额外空间。

7、1247.交换字符使得字符串相同

参考：LeetCode-1247. 交换字符使得字符串相同

有两个长度相同的字符串 s1 和 s2，且它们其中 只含有 字符 “x” 和 “y”，你需要通过「交换字符」的方式使这两个字符串相同。

每次「交换字符」的时候，你都可以在两个字符串中各选一个字符进行交换。

交换只能发生在两个不同的字符串之间，绝对不能发生在同一个字符串内部。也就是说，我们可以交换 s1[i] 和 s2[j]，但不能交换 s1[i] 和 s1[j]。

最后，请你返回使 s1 和 s2 相同的最小交换次数，如果没有方法能够使得这两个字符串相同，则返回 -1 。

示例 1：

输入：s1 = "xx", s2 = "yy"
输出：1
解释：
交换 s1[0] 和 s2[1]，得到 s1 = "yx"，s2 = "yx"。

示例 2：

输入：s1 = "xy", s2 = "yx"
输出：2
解释：
交换 s1[0] 和 s2[0]，得到 s1 = "yy"，s2 = "xx" 。
交换 s1[0] 和 s2[1]，得到 s1 = "xy"，s2 = "xy" 。
注意，你不能交换 s1[0] 和 s1[1] 使得 s1 变成 "yx"，因为我们只能交换属于两个不同字符串的字符。

示例 3：

输入：s1 = "xx", s2 = "xy"
输出：-1

提示：

• 1 <= s1.length, s2.length <= 1000

• s1.length == s2.length

• s1, s2 只包含 ‘x’ 或 ‘y’。

贪心

参考：算法通关手册（LeetCode）

• 如果 s1==s2，则不需要交换。

• 如果 s1 = “xx”，s2 = “yy”，则最少需要交换一次，才可以使两个字符串相等。

• 如果 s1 = “yy”，s2 = “xx”，则最少需要交换一次，才可以使两个字符串相等。

• 如果 s1 = “xy”，s2 = “yx”，则最少需要交换两次，才可以使两个字符串相等。

• 如果 s1 = “yx”，s2 = “xy”，则最少需要交换两次，才可以使两个字符串相等。

则可以总结为：

• “xx” 与 “yy”、“yy” 与 “xx” 只需要交换一次。

• “xy” 与 “yx”、“yx” 与 “xy” 需要交换两次。

我们把这两种情况分别进行统计。

• 当遇到 s1[i]==s2[i] 时直接跳过。

• 当遇到 s1[i] == ‘x’，s2[i] == ‘y’ 时，则统计数量到变量 xyCnt 中。

• 当遇到 s1[i] == ‘y’，s2[i] == ‘y’ 时，则统计数量到变量 yxCnt 中。

则最后我们只需要判断 xyCnt 和 yxCnt 的个数即可。(和非连续的元素组成一对进行交换**）**

• 如果 xyCnt+yxCnt 是奇数，则说明最终会有一个位置上的两个字符无法通过交换相匹配。

• 如果 xyCnt+yxCnt 是偶数，并且 xyCnt 为偶数，则 yxCnt 也为偶数。则优先交换 “xx” 与 “yy”、“yy” 与 “xx”。即每两个 xyCnt 对应一次交换，每两个 yxCnt 对应交换一次，则结果为xyCnt÷2+yxCnt÷2。

• 如果 xyCnt+yxCnt 是偶数，并且 xyCnt 为奇数，则 yxCnt 也为奇数。则优先交换 “xx” 与 “yy”、“yy” 与 “xx”。即每两个 xyCnt 对应一次交换，每两个 yxCnt 对应交换一次，则结果为 xyCnt÷2+yxCnt÷2。最后还剩一组 “xy” 与 “yx” 或者 “yx” 与 “xy”，则再交换一次，则结果为xyCnt÷2+yxCnt÷2+2。

以上结果可以统一写成 xyCnt÷2+yxCnt÷2+xyCnt % 2×2。

java

public class LeetCode_1247_greedy {
    public static void main(String[] args) {
        String s1 = "xx";
        String s2 = "yy";
        System.out.println(minimumSwap(s1, s2));
    }


    public static int minimumSwap(String s1, String s2) {
        int n = s1.length();
        // 从左到右遍历，统计两个字符串的每一个对应元素不相同的形式数量：xy、yx
        int xyCount = 0;
        int yxCount = 0;
        for (int i = 0; i < n; i++) {
            char a = s1.charAt(i);
            char b = s2.charAt(i);
            if (a == 'x' && b == 'y') {
                xyCount++;
            }
            if (a == 'y' && b == 'x') {
                yxCount++;
            }
        }


        // xy、yx的总和为奇数时无法完成交换
        if ((xyCount + yxCount) % 2 == 1) {
            return -1;
        }


        // xy两两之间构成xx和yy只要交换一次，yx两两之间构成yy和xx只要交换一次（和非连续的元素组成一对进行交换）
        // 奇数个xy、yx无法全部配对成xx、yy或者yy、xx，最后分别剩余一个xy和yx需要进行两次交换
        return xyCount / 2 + yxCount / 2 + (xyCount % 2) * 2;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是字符串的长度。需要遍历两个字符串一遍。

• 空间复杂度：O(1)，只需要常数空间。

8、1400.构造 K 个回文字符串

参考：LeetCode-1400. 构造 K 个回文字符串

给你一个字符串 s 和一个整数 k 。请你用 s 字符串中 所有字符 构造 k 个非空 回文串 。

如果你可以用 s 中所有字符构造 k 个回文字符串，那么请你返回 True ，否则返回 False 。

示例 1：

输入：s = "annabelle", k = 2
输出：true
解释：可以用 s 中所有字符构造 2 个回文字符串。
一些可行的构造方案包括："anna" + "elble"，"anbna" + "elle"，"anellena" + "b"

示例 2：

输入：s = "leetcode", k = 3
输出：false
解释：无法用 s 中所有字符构造 3 个回文串。

示例 3：

输入：s = "true", k = 4
输出：true
解释：唯一可行的方案是让 s 中每个字符单独构成一个字符串。

示例 4：

输入：s = "yzyzyzyzyzyzyzy", k = 2
输出：true
解释：你只需要将所有的 z 放在一个字符串中，所有的 y 放在另一个字符串中。那么两个字符串都是回文串。

示例 5：

输入：s = "cr", k = 7
输出：false
解释：我们没有足够的字符去构造 7 个回文串。

提示：

• 1 <= s.length <= 10^5

• s 中所有字符都是小写英文字母。

• 1 <= k <= 10^5

贪心

由于我们需要根据给定的字符串 s 构造出 k 个非空的回文串，那么一种容易想到的步骤是：

1. 求出字符串 s 最少可以构造的回文串个数 left；

2. 求出字符串 s 最多可以构造的回文串个数 right；

3. 找出在 [left,right] 范围内满足要求的那些值，并判断 k 是否在其中。

对于步骤 2 来说，它的答案很简单。我们设字符串 s 的长度为 ∣s∣，那么显然 s 最多可以构造的回文串个数就是 ∣s∣，即 s 中的每一个字符都单独构成一个回文串。

那么我们如何分析步骤 1 呢？我们需要考虑回文串的性质：回文串分为两类，第一类是长度为奇数，回文中心为一个字符，例如 abcba，abacaba 等；第二类是长度为偶数，回文中心为两个相同的字符，例如 abccba，abaccaba 等。我们可以发现，对于第一类回文串，只有一种字符出现了奇数次，其余所有字符都出现了偶数次；而对于第二类回文串，所有字符都出现了偶数次。

因此，如果 s 中有 p 个字符出现了奇数次，q 个字符出现了偶数次，那么 s 最少可以构造的回文串个数就为 p，这是因为每一种出现了奇数次的字符都必须放在不同的回文串中。特别地，如果 p=0，那么最少构造的回文串个数为 1。

通过简单的分析，我们得到了 left 的值为 max(p,1)，right 的值为 ∣s∣。那么最后还剩下步骤 1 了，对于 [left,right] 范围内的值，哪些是满足要求的呢？我们当然希望所有的值都是满足要求的，但这可以实现吗？

我们随意地给出一个回文串 ahykhbhkyha，可以发现，如果将回文中心 b 取出，这样我们就可以得到两个回文串 ahykhhkyha 和 b。接下来，我们将回文中心 hh 中取出一个 h，这样就得到了三个回文串 ahykhkyha，h 和 b。以此类推，最终我们可以得到 11 个回文串（即为初始回文串的长度），每一个回文串的长度均为 1。（针对全都是偶数个回文串ahykhhkyha分析过程也是一样）

因此我们就可以断定：对于 [left,right] 范围内的值，它们都是满足要求的：

• 我们知道 left 是满足要求的；

• 如果 x 是满足要求的，并且 x != right，那么我们一定可以找到一个回文串的长度大于 1。我们取出该回文串的回文中心（如果是第一类回文串）或者回文中心其中的一个字符（如果是第二类回文串），单独作为一个长度为 1 的回文串。这样我们就得到了 x+1 个回文串，那么 x+1 也是满足要求的。

通过归纳法，我们证明了上述的结论，因此只要 k 在 [left,right] 中，我们就返回 True，否则返回 False。

java

class Solution {
    public boolean canConstruct(String s, int k) {
        // 右边界为字符串的长度
        int right = s.length();
        // 统计每个字符出现的次数
        int[] occ = new int[26];
        for (int i = 0; i < right; ++i) {
            ++occ[s.charAt(i) - 'a'];
        }
        // 左边界为出现奇数次字符的个数
        int left = 0;
        for (int i = 0; i < 26; ++i) {
            if (occ[i] % 2 == 1) {
                ++left;
            }
        }
        // 注意没有出现奇数次的字符的特殊情况
        left = Math.max(left, 1);
        return left <= k && k <= right;
    }
}

复杂度分析

• 时间复杂度：O(N+∣Σ∣)，其中 N 是字符串 s 的长度，Σ 是字符集（即字符串中可能出现的字符种类数），在本题中字符串只会包含小写字母，因此 ∣Σ∣=26。我们需要对字符串 s 进行一次遍历，得到每个字符出现的次数，时间复杂度为 O(N)。在这之后，我们需要遍历每一种字符，统计出现奇数次的字符数量，时间复杂度为 O(∣Σ∣)。

• 空间复杂度：O(∣Σ∣)。我们需要使用数组或哈希表存储每个字符出现的次数。

数字贪心

9、402.移掉 K 位数字

参考：LeetCode-402. 移掉 K 位数字

给你一个以字符串表示的非负整数 num 和一个整数 k ，移除这个数中的 k 位数字，使得剩下的数字最小。请你以字符串形式返回这个最小的数字。

示例 1 ：

输入：num = "1432219", k = 3
输出："1219"
解释：移除掉三个数字 4, 3, 和 2 形成一个新的最小的数字 1219 。

示例 2 ：

输入：num = "10200", k = 1
输出："200"
解释：移掉首位的 1 剩下的数字为 200. 注意输出不能有任何前导零。

示例 3 ：

输入：num = "10", k = 2
输出："0"
解释：从原数字移除所有的数字，剩余为空就是 0 。

提示：

• 1 <= k <= num.length <= 10^5

• num 仅由若干位数字（0 - 9）组成

• 除了 0 本身之外，num 不含任何前导零

单调栈+贪心

若要使得剩下的数字最小，需要保证靠前的数字尽可能小

「删除一个数字」的贪心策略：

给定一个长度为 n 的数字序列 [D0D1D2D3…Dn−1]，从左往右找到第一个位置 i（i>0）使得 Di<Di−1，并删去 Di−1；如果不存在，说明整个数字序列单调不降，删去最后一个数字即可。(从左到右遍历，删除前一个数字比后一个大的数字)

考虑从左往右增量的构造最后的答案。我们可以用一个栈维护当前的答案序列，栈中的元素代表截止到当前位置，删除不超过 k 次个数字后，所能得到的最小整数。根据之前的讨论：在使用 k 个删除次数之前，栈中的序列从栈底到栈顶单调不降。

单调栈中遇到和栈顶相等的元素时，元素入栈不执行栈顶元素出栈操作，即维护单调不减栈，如 “112” k=1，如果第二个 ‘1’ 要入栈时弹出栈顶 ‘1’，结果就不是最小的。

考虑到栈的特点是后进先出，如果通过栈实现，则需要将栈内元素依次弹出然后进行翻转才能得到最小数。为了避免翻转操作，可以使用双端队列代替栈的实现。
java

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
public class LeetCode_402_stack {
    public static void main(String[] args) {
        String num = "1432219";
        int k = 3;
        System.out.println("最小的数字: " + removeKdigits(num, k));
    }


    public static String removeKdigits(String num, int k) {
        int n = num.length();
        Deque<Character> stack = new LinkedList<>();


        // 遍历每个数字入栈，保证栈内元素单调不减
        for (int i = 0; i < n; i++) {
            char digit = num.charAt(i);
            // 栈顶元素>当前元素时，删除栈顶元素可获得较小的结果
            while (!stack.isEmpty() && k > 0 && stack.peekLast() > digit) {
                stack.pollLast();
                k--;
            }
            stack.offerLast(digit);
        }


        // stack内还需要删除k个元素
        for (int i = 0; i < k; i++) {
            stack.pollLast();
        }


        // 处理前导0，有可能有多个前导0
        StringBuilder res = new StringBuilder();
        boolean leadingZero = true;
        while (!stack.isEmpty()) {
            char digit = stack.pollFirst();
            if (leadingZero && '0' == digit) {
                continue;
            }
            leadingZero = false;
            res.append(digit);
        }


        return res.isEmpty() ? "0" : res.toString();
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为字符串的长度。尽管存在嵌套循环，但内部循环最多运行 k 次。由于 0<k≤n，主循环的时间复杂度被限制在 2n 以内。对于主循环之外的逻辑，它们的时间复杂度是 O(n)，因此总时间复杂度为 O(n)。

• 空间复杂度：O(n)。栈存储数字需要线性的空间。

java-使用字符串模拟栈

public class LeetCocd_402_greedy {
    public static void main(String[] args) {
        String num = "1432219";
        int k = 3;
        System.out.println(removeKdigits(num, k));
    }


    public static String removeKdigits(String num, int k) {
        // 遍历数字每个字符入栈，保证数字单调递增，不满足条件的前一个元素出栈
        StringBuilder sb = new StringBuilder();
        for (char ch : num.toCharArray()) {
            // 前一个元素较大时弹出
            while (!sb.isEmpty() && ch < sb.charAt(sb.length() - 1) && k > 0) {
                sb.deleteCharAt(sb.length() - 1);
                k--;
            }
            sb.append(ch);
        }
        // 当前元素已经时单调递增序列，还差k个元素需要从末尾移除
        while (k > 0) {
            sb.deleteCharAt(sb.length() - 1);
            k--;
        }
        // 去掉前导0
        while (!sb.isEmpty() && sb.charAt(0) == '0') {
            sb.deleteCharAt(0);
        }
        return sb.isEmpty() ? "0" : sb.toString();
    }
}

python

def removeKdigits(num, k):
    stack = []
    # 构建单调递增的数字串
    for digit in num:
        while k and stack and digit < stack[-1]:
            stack.pop()
            k -= 1
        stack.append(digit)
    # 如果k>0，删除末尾的k个字符
    final_stack = stack[:-k] if k else stack
    # 抹去前导零
    return "".join(final_stack).lstrip('0') or "0"

10、670.最大交换

参考：LeetCode-670. 最大交换

给定一个非负整数，你至多可以交换一次数字中的任意两位。返回你能得到的最大值。

示例 1 :

输入: 2736
输出: 7236
解释: 交换数字2和数字7。

示例 2 :

输入: 9973
输出: 9973
解释: 不需要交换。

注意:

1. 给定数字的范围是 [0, 10^8]

排序+贪心

我们期望获得最大的数字和可以经过排序交换任意次得到的最大数字，前面几位一定相同，这样才可能得到通过一次交换获得最大的数字

• 针对数字的每一个字符进行降序排序得到最大的数字

• 只能交换一次所以将左侧第一个不在应该在的位置的数字交换到当前位置。

import java.util.Arrays;
public class LeetCode_670_greedy {
    public static void main(String[] args) {
        int num = 99735818;
        System.out.println(maximumSwap(num));
    }


    public static int maximumSwap(int num) {
        // 针对数字的每一个字符进行降序排序得到最大的数字，只能交换一次所以将左侧第一个不在应该在的位置的数字交换到当前位置
        char[] maxNumCharArr = String.valueOf(num).toCharArray();
        Arrays.sort(maxNumCharArr);
        int n = maxNumCharArr.length;
        for (int i = 0; i < n / 2; i++) {
            char tmp = maxNumCharArr[i];
            maxNumCharArr[i] = maxNumCharArr[n - i - 1];
            maxNumCharArr[n - i - 1] = tmp;
        }


        // 同时顺序遍历排序后的数组和原数字的字符，第一个不相同时进行该位置的数字交换
        StringBuilder numStr = new StringBuilder(String.valueOf(num));
        for (int i = 0; i < n; i++) {
            if (numStr.charAt(i) != maxNumCharArr[i]) {
                // 将最后一个出现较大元素位置和当前i位置交换
                char tmp = numStr.charAt(i);
                int index = numStr.lastIndexOf(String.valueOf(maxNumCharArr[i]));
                numStr.replace(i, i + 1, String.valueOf(maxNumCharArr[i]));
                numStr.replace(index, index + 1, String.valueOf(tmp));
                break;
            }
        }
        return Integer.parseInt(String.valueOf(numStr));
    }
}

复杂度分析

• 时间复杂度：O(log n)，n为num数字字符的长度，排序所需的时间为log n；

• 空间复杂度：O(n)，n为num数字字符的长度。

贪心

参考：670. 最大交换 -LeetCode全解

• 先将数字转为字符串 numCharArr，然后从右往左遍历字符串 numCharArr，用数组或哈希表 rightMaxIndex 记录每个数字右侧的最大数字的位置（可以是数字本身的位置）。

• 接着从左到右遍历 rightMaxIndex，如果 numCharArr[i]<numCharArr[rightMaxIndex[i]]，则进行交换，并退出遍历的过程。

• 最后将字符串 numCharArr 转为数字，即为答案。

public class LeetCode_670_greedy_2 {
    public static void main(String[] args) {
        int num = 1993;
        System.out.println(maximumSwap(num));
    }


    public static int maximumSwap(int num) {
        char[] numCharArr = String.valueOf(num).toCharArray();
        int n = numCharArr.length;
        // 从右向左遍历，计算每一个数字右边最大的数字（包含它本身）
        int[] rightMaxIndex = new int[n];
        rightMaxIndex[n - 1] = n - 1;
        for (int i = n - 2; i >= 0; i--) {
            // 这里需要取等号，寻找最右边的最后一个最大数字
            if (numCharArr[i] <= numCharArr[rightMaxIndex[i + 1]]) {
                rightMaxIndex[i] = rightMaxIndex[i + 1];
            } else {
                rightMaxIndex[i] = i;
            }
        }


        // 从左向右遍历原字符串数组，遇到第一个数字和其右边最大数字不相同的进行交换
        for (int i = 0; i < n; i++) {
            int j = rightMaxIndex[i];
            if (numCharArr[j] != numCharArr[i]) {
                char tmp = numCharArr[i];
                numCharArr[i] = numCharArr[j];
                numCharArr[j] = tmp;
                // 只进行一次交换
                break;
            }
        }
        return Integer.parseInt(String.valueOf(numCharArr));
    }
}

复杂度分析

• 时间复杂度：O(log n)，n为num数字字符的长度，遍历和交换操作都是常数级别；

• 空间复杂度：O(n)，n为num数字字符的长度。

11、738.单调递增的数字

参考：LeetCode-738. 单调递增的数字

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）

示例 1:

输入: n = 10
输出: 9

示例 2:

输入: n = 1234
输出: 1234

示例 3:

输入: n = 332
输出: 299

提示:

• 0 <= n <= 10^9

贪心

例如：98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]–，然后strNum[i]给为9，这样这个整数就是89，即小于98的最大的单调递增整数。

• **局部最优：**遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]–，然后strNum[i]给为9，可以保证这两位变成最大单调递增整数。

• **全局最优：**得到小于等于N的最大单调递增的整数。

但这里局部最优推出全局最优，还需要其他条件，即遍历顺序，和标记从哪一位开始统一改成9。

此时是从前向后遍历还是从后向前遍历呢？

• 从前向后遍历的话，遇到strNum[i - 1] > strNum[i]的情况，让strNum[i - 1]减一，但此时如果strNum[i - 1]减一了，可能又小于strNum[i - 2]。

• 这么说有点抽象，举个例子，数字：332，从前向后遍历的话，那么就把变成了329，此时2又小于了第一位的3了，真正的结果应该是299。

所以从前后向遍历会改变已经遍历过的结果！

那么从后向前遍历，就可以重复利用上次比较得出的结果了，从后向前遍历332的数值变化为：332 -> 329 -> 299

java

import java.util.Arrays;
public class LeetCode_738_greedy {
    public static void main(String[] args) {
        int n = 332;
        System.out.println(monotoneIncreasingDigits(n));
    }


    public static int monotoneIncreasingDigits(int n) {
        char[] digitList = Integer.toString(n).toCharArray();
        int len = digitList.length;


        // 从后向前遍历每个数字
        for (int i = len - 1; i > 0; i--) {
            // 如果前一个数大于当前数字，前一个数字-1，后面的数字全部置为9
            if (digitList[i - 1] > digitList[i]) {
                digitList[i - 1] = (char) ((int) digitList[i - 1] - 1);
                Arrays.fill(digitList, i, len, '9');
            }
        }
        return Integer.parseInt(String.valueOf(digitList));
    }
}

复杂度分析

• 时间复杂度：O(n)，n 为数字长度

• 空间复杂度：O(n)，需要一个字符串，转化为字符串操作更方便

python

def monotoneIncreasingDigits(n: int) -> int:
    # string不可变，转为list
    a = list(str(n))
    
    # 从后向前遍历
    for i in range(len(a) - 1, 0, -1):
        # 前一个数字小于后一个数字
        if int(a[i]) < int(a[i - 1]):
            # 前一个数字减1
            a[i - 1] = str(int(a[i - 1]) - 1)
            # 从i开始之后全部赋值为'9'
            a[i:] = '9' * (len(a) - i)
    return int("".join(a)) 

12、861.翻转矩阵后的得分

参考：LeetCode-861. 翻转矩阵后的得分

给你一个大小为 m x n 的二元矩阵 grid ，矩阵中每个元素的值为 0 或 1 。

一次 移动 是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。

在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的 得分 就是这些数字的总和。

在执行任意次 移动 后（含 0 次），返回可能的最高分数。

示例 1：

输入：grid = [[0,0,1,1],[1,0,1,0],[1,1,0,0]]
输出：39
解释：0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39

示例 2：

输入：grid = [[0]]
输出：1

提示：

• m == grid.length

• n == grid[i].length

• 1 <= m, n <= 20

• grid[i][j] 为 0 或 1

贪心-修改原数组

针对行列进行如下转化，可以使得总和最大：

• 为了得到最高的分数，矩阵的每一行的最左边的数都必须为 1。为了做到这一点，我们可以翻转那些最左边的数不为 1 的那些行，而其他的行则保持不动。

• 当将每一行的最左边的数都变为 1 之后，就只能列翻转了。为了使得总得分最大，我们要让每个列中 1 的数目尽可能多。因此，我们扫描除了最左边的列以外的每一列，如果该列 0 的数目多于 1 的数目，就翻转该列，其他的列则保持不变。

按照如上步骤直接修改原数组，以最直观的方式实现代码：

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
public class LeetCode_861_greedy {
    public static void main(String[] args) {
        int[][] grid = {{0, 0, 1, 1}, {1, 0, 1, 0}, {1, 1, 0, 0}};
        System.out.println(matrixScore(grid));
    }


    public static int matrixScore(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        Map<Integer, Integer> convertMap = new HashMap<>();
        convertMap.put(1, 0);
        convertMap.put(0, 1);


        // 遍历矩阵的第一列，为0的元素所在行进行转化
        for (int i = 0; i < m; i++) {
            if (grid[i][0] != 0) {
                continue;
            }
            for (int j = 0; j < n; j++) {
                grid[i][j] = convertMap.get(grid[i][j]);
            }
        }


        // 遍历矩阵的每一列，为0的元素数量超过一半则所在列进行转化
        for (int j = 1; j < n; j++) {
            int colSum = 0;
            for (int i = 0; i < m; i++) {
                colSum += grid[i][j];
            }
            if (2 * colSum >= m) {
                continue;
            }
            for (int i = 0; i < m; i++) {
                grid[i][j] = convertMap.get(grid[i][j]);
            }
        }


        // 按照行计算每个二进制的数值并累加
        int res = 0;
        for (int i = 0; i < m; i++) {
            String rowStr = Arrays.stream(grid[i]).mapToObj(String::valueOf).collect(Collectors.joining());
            res += Integer.parseInt(rowStr, 2);
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(mn)，其中 m 为矩阵行数，n 为矩阵列数。

• 空间复杂度：O(1)。

贪心-不改原数组

针对行列进行如下转化，可以使得总和最大：

• 为了得到最高的分数，矩阵的每一行的最左边的数都必须为 1。为了做到这一点，我们可以翻转那些最左边的数不为 1 的那些行，而其他的行则保持不动。

• 当将每一行的最左边的数都变为 1 之后，就只能列翻转了。为了使得总得分最大，我们要让每个列中 1 的数目尽可能多。因此，我们扫描除了最左边的列以外的每一列，如果该列 0 的数目多于 1 的数目，就翻转该列，其他的列则保持不变。

实际编写代码时，我们无需修改原矩阵，而是可以计算每一列对总分数的「贡献」，从而直接计算出最高的分数。假设矩阵共有 m 行 n 列，计算方法如下：

• 对于最左边的列而言，由于最优情况下，它们的取值都为 1，因此每个元素对分数的贡献都为 2^(n−1)，总贡献为 m×2^(n−1)。

• 对于第 j 列（j>0，此处规定最左边的列是第 0 列）而言，我们统计这一列 0,1 的数量，令其中的最大值为 k，则 k 是列翻转后的 1 的数量，该列的总贡献为 k×2^(n−j−1)。需要注意的是，在统计 0,1 的数量的时候，要考虑最初进行的行反转。

java

public class LeetCode_861_greedy_2 {
    public static void main(String[] args) {
        int[][] grid = {{0, 0, 1, 1}, {1, 0, 1, 0}, {1, 1, 0, 0}};
        System.out.println(matrixScore(grid));
    }


    public static int matrixScore(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;


        // 第一列的元素都是1，直接计算加入总和中
        int res = m * (1 << (n - 1));


        // 矩阵的第一列为0的元素所在行都需要进行转化，转化之后每一列0数量过半的也需要进行转化
        // 可以按照列进行计算，相同列对总数贡献是一样的2^(n-j-1)，只要统计每一列的1的个数就能计算出当前列的总
        // 注意要考虑行是否被转化过，其次1的个数少于列元素数的一半时也需要转化


        // 遍历矩阵的每一列
        for (int j = 1; j < n; j++) {
            // 统计当前列进过最终转化后1的个数（行转化）
            int nOne = 0;
            for (int i = 0; i < m; i++) {
                // 判断当前行是否被转化过
                if (grid[i][0] == 1) {
                    nOne += grid[i][j];
                } else {
                    // 如果这一行进行了行反转，则该元素的实际取值为 1 - grid[i][j]
                    nOne += (1 - grid[i][j]);
                }
            }
            // 判断当前列是否需要转化，无论是否转化取较大的值
            nOne = Math.max(nOne, m - nOne);
            // 当前列的总和加入结果中
            res += nOne * (1 << (n - j - 1));
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(mn)，其中 m 为矩阵行数，n 为矩阵列数。

• 空间复杂度：O(1)。

序列贪心

13、1005.K次取反后最大化的数组和

参考：LeetCode-1005. K 次取反后最大化的数组和

给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）

以这种方式修改数组后，返回数组可能的最大和。

示例 1：

输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。

示例 2：

输入：nums = [3,-1,0,2], k = 3
输出：6
解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。

示例 3：

输入：nums = [2,-3,-1,5,-4], k = 2
输出：13
解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。

提示：

• 1 <= nums.length <= 10^4

• -100 <= nums[i] <= 100

• 1 <= k <= 10^4

优先队列

• 构建优先队列，小的元素在队首；

• 循环弹出队首最小元素，取反后重新加入队列。k次循环后就是最终的元素集合；

• 求和。

import java.util.PriorityQueue;
public class LeetCode_1005_1_greedy {
    public static void main(String[] args) {
        int[] nums = {3, -1, 0, 2};
        int k = 3;
        System.out.println(largestSumAfterKNegations(nums, k));
    }


    public static int largestSumAfterKNegations(int[] nums, int k) {
        // 构建优先队列，小的元素在队首
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        for (int num : nums) {
            queue.offer(num);
        }
        // 循环弹出队首最小元素，取反后重新加入队列
        for (int i = 0; i < k; i++) {
            int tmp = -1 * queue.poll();
            queue.offer(tmp);
        }
        // 计算元素和
        int res = 0;
        while(!queue.isEmpty()) {
            res += queue.poll();
        }
        return res;
    }
}

复杂度分析

• 时间复杂度: O((n+k)logn)，构建优先队列的时间复杂度；

• 空间复杂度: O(n），优先队列存储数组元素所额外使用的空间。

贪心

由于我们希望数组的和尽可能大，因此除非万不得已，我们应当总是修改负数，并且优先修改值最小的负数。因为将负数 -x 修改成 x 会使得数组的和增加 2x，所以这样的贪心操作是最优的。

当给定的 K 小于等于数组中负数的个数时，我们按照上述方法从小到大依次修改每一个负数即可。但如果 K 的值较大，那么我们不得不去修改非负数（即正数或者 0）了。由于修改 0 对数组的和不会有影响，而修改正数会使得数组的和减小，因此：

• 如果数组中存在 0，那么我们可以对它进行多次修改，直到把剩余的修改次数用完；

• 如果数组中不存在 0 并且剩余的修改次数是偶数，由于对同一个数修改两次等价于不进行修改，因此我们也可以在不减小数组的和的前提下，把修改次数用完；

• 如果数组中不存在 0 并且剩余的修改次数是奇数，那么我们必然需要使用单独的一次修改将一个正数变为负数（剩余的修改次数为偶数，就不会减小数组的和）。为了使得数组的和尽可能大，我们就选择那个最小的正数。

需要注意的是，在之前将负数修改为正数的过程中，可能出现了（相较于原始数组中最小的正数）更小的正数，这一点不能忽略。

细节

为了实现上面的算法，我们可以对数组进行排序，首先依次遍历每一个负数（将负数修改为正数），再遍历所有的数（将 0 或最小的正数进行修改）。

java

import java.util.Arrays;
public class LeetCode_1005_1_greedy {
    public static void main(String[] args) {
        int[] nums = {-2, 9, 9, 8, 4};
        int k = 5;
        System.out.println(largestSumAfterKNegations(nums, k));
    }


    public static int largestSumAfterKNegations(int[] nums, int k) {
        Integer[] arr = Arrays.stream(nums).boxed().toArray(Integer[]::new);
        // 根据元素绝对值降序排序
        Arrays.sort(arr, (a, b) -> Math.abs(b) - Math.abs(a));
        // 遍历数组，从左到右将负数取反（k次以内）
        for (int i = 0; i < arr.length && k > 0; i++) {
            if (arr[i] < 0) {
                k--;
                arr[i] = -arr[i];
            }
        }


        // k还有剩余，将最后一个最小的元素进行剩余k次取反
        if (k % 2 == 1) {
            arr[arr.length - 1] *= -1;
        }
        return Arrays.stream(arr).mapToInt(Integer::intValue).sum();
    }
}

复杂度分析

• 时间复杂度: O(nlogn)，数组排序的时间复杂度。

• 空间复杂度: O(1）

python

def largestSumAfterKNegations(A: list, K: int) -> int:
    # 将A按绝对值从大到小排列
    A = sorted(A, key=abs, reverse=True)
    for i in range(len(A)):
        # 优先将绝对值较大的负数转为正数
        if K > 0 and A[i] < 0:
            A[i] *= -1
            K -= 1
    # 负数已经全部转正，还有K次未用完
    if K > 0:
        A[-1] *= (-1) ** K  # 取A最后一个数只需要写-1
    return sum(A)

14、53.最大子序和

参考：LeetCode-53. 最大子数组和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= 10^5

• -10^4 <= nums[i] <= 10^4

动态规划

用 f(i) 代表以第 i 个数结尾的「连续子数组的最大和」，我们只需要求出每个位置的 f(i)，然后返回 f 数组中的最大值即可。那么我们如何求 f(i) 呢？

可以考虑 nums[i] 单独成为一段还是加入 f(i−1) 对应的那一段，这取决于 nums[i] 和 f(i−1)+nums[i] 的大小，我们希望获得一个比较大的，于是可以写出这样的动态规划转移方程：f(i)=max{f(i−1)+nums[i], nums[i]}

public class LeetCode_53_1_dp {
    public static void main(String[] args) {
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        System.out.println(maxSubArray(nums));
    }


    public static int maxSubArray(int[] nums) {
        // 以第i个元素为最后一个元素的连续子序列的最大和，dp[i] = max(dp[i-1] + nums[i], nums[i])
        int dp = nums[0];
        int res = dp;
        for (int num : nums) {
            // i元素有两个选择：当前元素加入前面的序列、当前元素单独作为一个序列
            dp = Math.max(dp + num, num);
            res = Math.max(res, dp);
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为 nums 数组的长度。我们只需要遍历一遍数组即可求得答案。

• 空间复杂度：O(1)。我们只需要常数空间存放若干变量

python

def maxSubArray( nums):
    if len(nums) == 0:
        return 0
    dp = [0] * len(nums)
    dp[0] = nums[0]
    result = dp[0]
    for i in range(1, len(nums)):
        dp[i] = max(dp[ i -1] + nums[i], nums[i])  # 状态转移公式
        result = max(result, dp[i])  # result 保存dp[i]的最大值
    return result

贪心

参考：leetCode 53.最大子数和 图解 + 贪心算法/动态规划+优化

如果 -2 1 在一起，计算起点的时候，一定是从1开始计算，因为负数只会拉低总和，这就是贪心贪的地方！

• 局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。

• 全局最优：选取最大“连续和”

局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。

从代码角度上来讲：

遍历nums，从头开始用count累积，如果count一旦加上nums[i]变为负数，那么就应该从nums[i+1]开始从0累积count了，因为已经变为负数的count，只会拖累总和。

这相当于是暴力解法中的不断调整最大子序和区间的起始位置。

那有同学问了，区间终止位置不用调整么？ 如何才能得到最大“连续和”呢？

区间的终止位置，其实就是如果count取到最大值了，及时记录下来了

java

public class LeetCode_53_2_greedy {
    public static void main(String[] args) {
        int[] nums = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
        System.out.println(maxSubArray(nums));
    }


    public static int maxSubArray(int[] nums) {
        int res = Integer.MIN_VALUE;
        // 当子序列和<0时，就没必要把下一个元素加进来，和负数相加只会变得更小，直接从下一个元素开始累计
        int curSum = 0;
        for (int num : nums) {
            // 子序列和<0则从下一个元素开始累计
            curSum = curSum < 0 ? num : curSum + num;
            res = Math.max(res, curSum);
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为 nums 数组的长度。我们只需要遍历一遍数组即可求得答案。

• 空间复杂度：O(1)。

python

def maxSubArray(nums: list) -> int:
    result = -float('inf')
    count = 0
    for i in range(len(nums)):
        count += nums[i]
        # 记录子序列最大和
        if count > result:
            result = count
        # 和为负责重置和，以下一个点为起点继续遍历
        if count <= 0:
            count = 0
    return result

15、406.根据身高重建队列

参考：LeetCode-406. 根据身高重建队列

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

示例 1：

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

示例 2：

输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]
输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]

提示：

• 1 <= people.length <= 2000

• 0 <= hi <= 10^6

• 0 <= ki < people.length

• 题目数据确保队列可以被重建

排序+贪心

本题有两个维度，h和k。遇到两个维度权衡的时候，一定要先确定一个维度，再确定另一个维度。如果两个维度一起考虑一定会顾此失彼。

对于本题相信大家困惑的点是先确定k还是先确定h呢，也就是究竟先按h排序呢，还先按照k排序呢？

• 如果按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件，两个维度哪一个都没确定下来。

• 那么按照身高h来排序呢，身高一定是从大到小排（身高相同的话则k小的站前面），让高个子在前面。

此时我们可以确定一个维度了，就是身高，前面的节点一定都比本节点高！

那么只需要按照k为下标重新插入队列就可以了，为什么呢？

以图中{5,2} 为例：

按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。

所以在按照身高从大到小排序后：

• 局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

• 全局最优：最后都做完插入操作，整个队列满足题目队列属性

回归本题，整个插入过程如下：

排序完的people： [[7,0], [7,1], [6,1], [5,0], [5,2]，[4,4]]

插入的过程：

• 插入[7,0]：[[7,0]]

• 插入[7,1]：[[7,0],[7,1]]

• 插入[6,1]：[[7,0],[6,1],[7,1]]

• 插入[5,0]：[[5,0],[7,0],[6,1],[7,1]]

• 插入[5,2]：[[5,0],[7,0],[5,2],[6,1],[7,1]]

• 插入[4,4]：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]

此时就按照题目的要求完成了重新排列。

java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class LeetCode_406_greedy {
    public static void main(String[] args) {
        int[][] people = {{7, 0}, {4, 4}, {7, 1}, {5, 0}, {6, 1}, {5, 2}};
        System.out.println(Arrays.deepToString(reconstructQueue(people)));
    }


    public static int[][] reconstructQueue(int[][] people) {
        // 按照身高h降序、序数k升序对数组进行排序
        Arrays.sort(people, (people1, people2) -> {
            if (people1[0] != people2[0]) {
                return people2[0] - people1[0];
            }
            return people1[1] - people2[1];
        });


        // 按照排序后的顺序，将元素插入结果中的索引为k的位置（先插入的数据较大，所以不会受后插入数据影响）
        int n = people.length;
        List<int[]> res = new ArrayList<>(n);
        for (int[] person : people) {
            res.add(person[1], person);
        }
        return res.toArray(new int[n][]);
    }
}

复杂度分析

• 时间复杂度：O(n^2)，其中 n 是数组 people 的长度。我们需要 O(nlogn) 的时间进行排序，随后需要 O(n^2) 的时间遍历每一个人并将他们放入队列中。由于前者在渐近意义下小于后者，因此总时间复杂度为 O(n^2)。

• 空间复杂度：O(logn)。

python

def reconstructQueue(people: list) -> list:
    # 先按照h维度的身高顺序从高到低排序。确定第一个维度
    # lambda返回的是一个元组：当-x[0](维度h）相同时，再根据x[1]（维度k）从小到大排序
    people.sort(key=lambda x: (-x[0], x[1]))
    que = []
    # 根据每个元素的第二个维度k，贪心算法，进行插入
    # people已经排序过了：同一高度时k值小的排前面。
    for p in people:
        que.insert(p[1], p)
    return que

16、376.摆动序列

参考：LeetCode-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

思路

解决本题前，我们先进行一些约定：

• 某个序列被称为「上升摆动序列」，当且仅当该序列是摆动序列，且最后一个元素呈上升趋势。如序列 [1,3,2,4] 即为「上升摆动序列」。

• 某个序列被称为「下降摆动序列」，当且仅当该序列是摆动序列，且最后一个元素呈下降趋势。如序列 [4,2,3,1] 即为「下降摆动序列」。

• 特别地，对于长度为 1 的序列，它既是「上升摆动序列」，也是「下降摆动序列」。

• 序列中的某个元素被称为「峰」，当且仅当该元素两侧的相邻元素均小于它。如序列 [1,3,2,4] 中，3 就是一个「峰」。

• 序列中的某个元素被称为「谷」，当且仅当该元素两侧的相邻元素均大于它。如序列 [1,3,2,4] 中，2 就是一个「谷」。

• 特别地，对于位于序列两端的元素，只有一侧的相邻元素小于或大于它，我们也称其为「峰」或「谷」。如序列 [1,3,2,4] 中，1 也是一个「谷」，4 也是一个「峰」。

• 因为一段相邻的相同元素中我们最多只能选择其中的一个，所以我们可以忽略相邻的相同元素。现在我们假定序列中任意两个相邻元素都不相同，即要么左侧大于右侧，要么右侧大于左侧。对于序列中既非「峰」也非「谷」的元素，我们称其为「过渡元素」。如序列 [1,2,3,4] 中，2 和 3 都是「过渡元素」。

贪心

只需要统计该序列中「峰」与「谷」的数量即可（注意序列两端的数也是「峰」或「谷」），但需要注意处理相邻的相同元素。

在实际代码中，我们记录当前序列的上升下降趋势。每次加入一个新元素时，用新的上升下降趋势与之前对比，如果出现了「峰」或「谷」，答案加一，并更新当前序列的上升下降趋势

用示例二来举例，如图所示：

• 局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

• 整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计数组的峰值数量就可以了（相当于是删除单一坡度上的节点，然后统计长度）

这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点。

**数组最左面和最右面是最不好统计的。**例如序列[2,5]，它的峰值数量是2，如果靠统计差值来计算峰值个数就需要考虑数组最左面和最右面的特殊情况。

所以可以针对序列[2,5]，可以假设为[2,2,5]，这样它就有坡度了即preDiff = 0，如图：

java

public class LeetCode_376_1_greedy {
    public static void main(String[] args) {
        int[] nums = {1, 7, 4, 9, 2, 5};
        System.out.println(wiggleMaxLength(nums));
    }


    public static int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return n;
        }


        // 计算局部区间的峰、谷数量，就是最终的摆动序列的最长子序列
        int prediff = nums[1] - nums[0];
        int res = prediff == 0 ? 1 : 2;
        int curdiff;
        for (int i = 2; i < n; i++) {
            curdiff = nums[i] - nums[i-1];
            // 锋、谷交错，和前一个差值正负值相反
            if ((curdiff > 0 && prediff <= 0) || (curdiff < 0 && prediff >= 0)) {
                res++;
                prediff = curdiff;
            }
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是序列的长度。我们只需要遍历该序列一次。

• 空间复杂度：O(1)。我们只需要常数空间来存放若干变量

python

从后向前遍历：

针对以上情形，result初始为1（默认最右面有一个峰值），此时curDiff > 0 && preDiff <= 0，那么result++（计算了左面的峰值），最后得到的result就是2（峰值个数为2即摆动序列长度为2）

def wiggleMaxLength(nums: list) -> int:
    # 题目里nums长度大于等于1，当长度为1时，其实到不了for循环里去，所以不用考虑nums长度
    preC, curC, res = 0, 0, 1
    for i in range(len(nums) - 1):
        curC = nums[i + 1] - nums[i]
        if curC * preC <= 0 and curC != 0:  # 差值为0时，不算摆动
            res += 1
            # 如果当前差值和上一个差值为一正一负时，才需要用当前差值替代上一个差值
            preC = curC
    return res

动态规划

参考：leetcode(力扣) 376. 摆动序列 (贪心 & 动态规划)

每当我们选择一个元素作为摆动序列的一部分时，这个元素要么是上升的，要么是下降的，这取决于前一个元素的大小。那么列出状态表达式为：

• up[i] 表示以前 i 个元素中的某一个为结尾的最长的「上升摆动序列」的长度。

• down[i] 表示以前 i 个元素中的某一个为结尾的最长的「下降摆动序列」的长度。

• 序列中的某个元素被称为**“峰”，当且仅当该元素两侧的相邻元素均小于它。例如序列[1,3,2,4]中的 3 就是一个“峰”**

• 序列中的某个元素被称为**“谷”，当且仅当该元素两侧的相邻元素均大于它。例如序列[1,3,2,4]中的2** 就是一个**“谷”**

• 特别地，对于位于序列两端的元素，只有一侧的相邻元素小于或大于它，也称其为**“峰”或“谷”。如序列[1,3,2,4]中，1 也是一个“谷”，4 是一个“峰”**

状态定义：

我们可以定义两个状态：

• up[i]：表示以 nums[i] 结尾，并且 nums[i] 是上升的摆动序列的最长长度。

• down[i]：表示以 nums[i] 结尾，并且 nums[i] 是下降的摆动序列的最长长度。

状态转移：

对于每一个 i，我们需要考虑所有 j < i 的情况：

• 如果 nums[i] > nums[j]，那么 nums[i] 可以接在以 nums[j] 结尾的下降序列后面形成一个更长的上升序列，山谷-山峰 ，此时最长长度+1，要么就维持原状也就是 山峰 -山峰，因此 up[i] = max(up[i], down[j] + 1)。

• 如果 nums[i] < nums[j]，那么 nums[i] 可以接在以 nums[j] 结尾的上升序列后面形成一个更长的下降序列，变成 山峰-山谷，此时最长长度+1，要么就是维持原状， 山谷-山谷，因此 down[i] = max(down[i], up[j] + 1)。

初始化时，每个位置 i 的 up[i] 和 down[i] 都至少为1，因为单个数字本身就可以构成一个长度为1的摆动序列。

public class LeetCode_376_2_dp {
    public static void main(String[] args) {
        int[] nums = {1, 7, 4, 9, 2, 5};
        System.out.println(wiggleMaxLength(nums));
    }


    public static int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return n;
        }


        // 计算以每个元素结尾的上摆、下摆序列的最长长度
        int[] up = new int[n];
        int[] down = new int[n];
        up[0] = 1;
        down[0] = 1;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                up[i] = Math.max(up[i - 1], down[i - 1] + 1);
                down[i] = down[i - 1];
            } else if (nums[i] < nums[i - 1]) {
                down[i] = Math.max(down[i - 1], up[i - 1] + 1);
                up[i] = up[i - 1];
            } else {
                up[i] = up[i - 1];
                down[i] = down[i - 1];
            }
        }
        return Math.max(down[n - 1], up[n - 1]);
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是序列的长度。我们只需要遍历该序列一次。

• 空间复杂度：O(n)，其中 n 是序列的长度。我们需要开辟两个长度为 n 的数组

动态规划-空间优化

和方法一相比，仅需要前一个状态来进行转移，所以我们维护两个变量即可。

public class LeetCode_376_2_dp {
    public static void main(String[] args) {
        int[] nums = {1, 7, 4, 9, 2, 5};
        System.out.println(wiggleMaxLength(nums));
    }


    public static int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return n;
        }


        // 计算以每个元素结尾的上摆、下摆序列的最长长度
        int up = 1;
        int down = 1;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                up = Math.max(up, down + 1);
            } else if (nums[i] < nums[i - 1]) {
                down = Math.max(down, up + 1);
            }
        }
        return Math.max(down, up);
    }
}

注意到每有一个「峰」到「谷」的下降趋势，down 值才会增加，每有一个「谷」到「峰」的上升趋势，up 值才会增加。且过程中 down 与 up 的差的绝对值值恒不大于 1，即 up≤down+1 且 down≤up+1，于是有 max(up,down+1)=down+1 且 max(up+1,down)=up+1。这样我们可以省去不必要的比较大小的过程。

public class LeetCode_376_2_dp {
    public static void main(String[] args) {
        int[] nums = {1, 7, 4, 9, 2, 5};
        System.out.println(wiggleMaxLength(nums));
    }


    public static int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return n;
        }


        // 计算以每个元素结尾的上摆、下摆序列的最长长度
        int up = 1;
        int down = 1;
        for (int i = 1; i < n; i++) {
            if (nums[i] > nums[i - 1]) {
                up = down + 1;
            } else if (nums[i] < nums[i - 1]) {
                down = up + 1;
            }
        }
        return Math.max(down, up);
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是序列的长度。我们只需要遍历该序列一次；

• 空间复杂度：O(1)。我们只需要常数空间来存放若干变量。

17、1029.两地调度

参考：LeetCode-1029. 两地调度

公司计划面试 2n 人。给你一个数组 costs ，其中 costs[i] = [aCosti, bCosti] 。第 i 人飞往 a 市的费用为 aCosti ，飞往 b 市的费用为 bCosti 。

返回将每个人都飞到 a 、b 中某座城市的最低费用，要求每个城市都有 n 人抵达。

示例 1：

输入：costs = [[10,20],[30,200],[400,50],[30,20]]
输出：110
解释：
第一个人去 a 市，费用为 10。
第二个人去 a 市，费用为 30。
第三个人去 b 市，费用为 50。
第四个人去 b 市，费用为 20。


最低总费用为 10 + 30 + 50 + 20 = 110，每个城市都有一半的人在面试。

示例 2：

输入：costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]
输出：1859

示例 3：

输入：costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]]
输出：3086

提示：

• 2 * n == costs.length

• 2 <= costs.length <= 100

• costs.length 为偶数

• 1 <= aCosti, bCosti <= 1000

贪心

我们先假设所有人都去了城市 a。然后令一半的人再去城市 b。现在的问题就变成了，让一半的人改变城市去向，从原本的 a 城市改成 b 城市的最低费用为多少。

已知第 i 个人更换去向的费用为「去城市 b 的费用 - 去城市 a 的费用」。所以我们可以根据「去城市 b 的费用 - 去城市 a 的费用」对数组 costs 进行排序，让前 n 个改变方向去城市 b，后 n 个人去城市 a。

最后统计所有人员的费用，将其返回即可。

可以考虑成所有人都去了a，现在需要把n个人从a调到b，当前都去a地的总花费已经确定，最终目的是使得总花费最小。调去b的n人 花费bi如果比ai更小总花费就能减少bi-ai，所以根据bi-ai的数值进行排序，尽可能小的bi-ai可以使得总花费最小。
java

import java.util.Arrays;
import java.util.Comparator;
public class LeetCode_1029_greedy {
    public static void main(String[] args) {
        int[][] costs = {{259, 770}, {448, 54}, {926, 667}, {184, 139}, {840, 118}, {577, 469}};
        System.out.println(twoCitySchedCost(costs));
    }


    public static int twoCitySchedCost(int[][] costs) {
        int n = costs.length / 2;
        // 假设2n个人先去a，n个人再改签去b，改签费用最少的n个人去b可以使得总花费最小
        // 按照bi-ai进行升序排序，排在前面的是改签去b花费最小的n个人
        Arrays.sort(costs, Comparator.comparingInt(cost -> cost[1] - cost[0]));
        // 前n个人去b，后n个人去a
        int res = 0;
        for (int i = 0; i < n; i++) {
            res += costs[i][1];
            res += costs[i + n][0];
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(NlogN)，需要对 price_A - price_B 进行排序。

• 空间复杂度：O(1)。

区间贪心

18、55.跳跃游戏

参考：LeetCode-55. 跳跃游戏

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：

输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

提示：

• 1 <= nums.length <= 10^4

• 0 <= nums[i] <= 10^5

贪心

刚看到本题一开始可能想：当前位置元素如果是3，我究竟是跳一步呢，还是两步呢，还是三步呢，究竟跳几步才是最优呢？

其实跳几步无所谓，关键在于可跳的覆盖范围！不一定非要明确一次究竟跳几步，每次取最大的跳跃步数，这个就是可以跳跃的覆盖范围。这个范围内，别管是怎么跳的，反正一定可以跳过来。

那么这个问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点！

每次移动取最大跳跃步数（得到最大的覆盖范围），每移动一个单位，就更新最大覆盖范围。

• 贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围）

• 整体最优解：最后得到整体最大覆盖范围，看是否能到终点。

局部最优推出全局最优，找不出反例，试试贪心！如图：

• i每次移动只能在cover的范围内移动，每移动一个元素，cover得到该元素数值（新的覆盖范围）的补充，让i继续移动下去。

• 而cover每次只取 max(该元素数值补充后的范围, cover本身范围)。

• 如果cover大于等于了终点下标，直接return true就可以了。

java

public class LeetCode_55_1_greedy {
    public static void main(String[] args) {
        int[] nums = {3, 2, 1, 0, 4};
        System.out.println(canJump(nums));
    }


    public static boolean canJump(int[] nums) {
        int rightmost = nums[0];
        int n = nums.length;
        for (int i = 1; i < n; i++) {
            if (i <= rightmost) {
                rightmost = Math.max(rightmost, i + nums[i]);
                if (rightmost >= n - 1) {
                    return true;
                }
            }
        }
        return false;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的大小。只需要访问 nums 数组一遍，共 n 个位置。

• 空间复杂度：O(1)，不需要额外的空间开销

python

def canJump(nums: list) -> bool:
    n, rightmost = len(nums), 0
    for i in range(n):
        # 遍历的i必须在最长可到达范围内
        if i <= rightmost:
            rightmost = max(rightmost, i + nums[i])
        if rightmost >= n - 1:
            return True
    return False

19、45.跳跃游戏II

参考：LeetCode-45. 跳跃游戏 II

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

• 0 <= j <= nums[i]

• i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

示例 2:

输入: nums = [2,3,0,1,4]
输出: 2

提示:

• 1 <= nums.length <= 10^4

• 0 <= nums[i] <= 1000

• 题目保证可以到达 nums[n-1]

贪心-反向查找出发位置

目标是到达数组的最后一个位置，因此我们可以考虑最后一步跳跃前所在的位置，该位置通过跳跃能够到达最后一个位置。

如果有多个位置通过跳跃都能够到达最后一个位置，那么我们应该如何进行选择呢？直观上来看，我们可以「贪心」地选择距离最后一个位置最远的那个位置，也就是对应下标最小的那个位置。因此，我们可以从左到右遍历数组，选择第一个满足要求的位置。

找到最后一步跳跃前所在的位置之后，我们继续贪心地寻找倒数第二步跳跃前所在的位置，以此类推，直到找到数组的开始位置。

public class LeetCode_45_1_greedy {
    public static void main(String[] args) {
        int[] nums = {2, 3, 1, 1, 4};
        System.out.println(jump(nums));
    }


    public static int jump(int[] nums) {
        // 从后向前遍历，每次寻找能够达到当前节点的最左边的节点
        int right = nums.length - 1;
        int steps = 0;
        while (right > 0) {
            for (int i = 0; i < right; i++) {
                // 寻找左侧跨度最大的结点
                if (i + nums[i] >= right) {
                    right = i;
                    steps++;
                    break;
                }
            }
        }
        return steps;
    }
}

复杂度分析

• 时间复杂度：O(n^2)，其中 n 是数组长度。有两层嵌套循环，在最坏的情况下，例如数组中的所有元素都是 1，position 需要遍历数组中的每个位置，对于 position 的每个值都有一次循环。

• 空间复杂度：O(1)。

贪心-正向查找可到达的最大位置

本题要计算最小步数，那么就要想清楚什么时候步数才一定要加一呢？

贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。

思路虽然是这样，但在写代码的时候还不能真的就能跳多远跳远，那样就不知道下一步最远能跳到哪里了。

所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数！

这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。

如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。

如图：

图中覆盖范围的意义在于，只要红色的区域，最多两步一定可以到！（不用管具体怎么跳，反正一定可以跳到）

从图中可以看出来，就是移动下标达到了当前覆盖的最远距离下标时，步数就要加一，来增加覆盖距离。最后的步数就是最少步数。

这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时

• 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。

• 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。

在遍历数组时，我们不访问最后一个元素，这是因为在访问最后一个元素之前，我们的边界一定大于等于最后一个位置，否则就无法跳到最后一个位置了。如果访问最后一个元素，在边界正好为最后一个位置的情况下，我们会增加一次「不必要的跳跃次数」，因此我们不必访问最后一个元素

java

public class LeetCode_45_2_greedy {
    public static void main(String[] args) {
        int[] nums = {2, 3, 1, 1, 4};
        System.out.println(jump(nums));
    }


    public static int jump(int[] nums) {
        int curDistance = 0;
        int nextDistance = 0;
        int res = 0;
        int n = nums.length;
        // 起点开始从左到右遍历，记录当前区间内能够到达的最远位置，如果遍历到最远位置还没到达终点则步数+1
        for (int i = 0; i < n - 1; i++) {
            nextDistance = Math.max(nextDistance, i + nums[i]);
            if (i == curDistance) {
                res++;
                curDistance = nextDistance;
                // 当前最大范围已经覆盖终点
                if (nextDistance >= n - 1) {
                    break;
                }
            }
        }
        return res;
    }
}

复杂度分析

• 时间复杂度：O(n)，其中 n 是数组长度。

• 空间复杂度：O(1)。

python

def jump(nums: list) -> int:
    if len(nums) == 1: return 0
    ans = 0
    curDistance = 0
    nextDistance = 0
    for i in range(len(nums)):
        nextDistance = max(i + nums[i], nextDistance)
        # 到达当前覆盖最远距离下标
        if i == curDistance:
            # 未到达终点
            if curDistance != len(nums) - 1:
                ans += 1  # 到达最远距离，步数+1
                curDistance = nextDistance
                # 到达终点
                if nextDistance >= len(nums) - 1: break
    return ans

20、452.用最少数量的箭引爆气球

参考：LeetCode-452. 用最少数量的箭引爆气球

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

示例 2：

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

示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2

示例 4：

输入：points = [[1,2]]
输出：1

示例 5：

输入：points = [[2,3],[2,3]]
输出：1

提示:

• 1 <= points.length <= 10^5

• points[i].length == 2

• -2^31 <= xstart < xend <= 2^31 - 1

排序+贪心

• 局部最优：当气球出现重叠，一起射，所用弓箭最少。

• 全局最优：把所有气球射爆所用弓箭最少。

为了让气球尽可能的重叠，需要对数组进行排序。那么按照气球起始位置排序，还是按照气球终止位置排序呢？其实都可以！只不过对应的遍历顺序不同，我就按照气球的起始位置排序了。

既然按照起始位置排序，那么就从前向后遍历气球数组，靠左尽可能让气球重复。从前向后遍历遇到重叠的气球了怎么办？如果气球重叠了，重叠气球中右边边界的最小值之前的区间一定需要一个弓箭。

以题目示例： [[10,16],[2,8],[1,6],[7,12]]为例，如图：（方便起见，已经排序）

可以看出首先第一组重叠气球，一定是需要一个箭，气球3，的左边界大于了 第一组重叠气球的最小右边界，所以再需要一支箭来射气球3了。

java

import java.util.Arrays;
import java.util.Comparator;
public class LeetCode_452_greedy_2 {
    public static void main(String[] args) {
        int[][] points = {{3, 9}, {7, 12}, {3, 8}, {6, 8}, {9, 10}, {2, 9}, {0, 9}, {3, 9}, {0, 6}, {2, 8}};
        System.out.println(findMinArrowShots(points));
    }


    public static int findMinArrowShots(int[][] points) {
        int n = points.length;
        // 根据左侧范围值进行升序排序
        Arrays.sort(points, Comparator.comparingInt(point -> point[0]));


        // 遍历排序后的数组，如果横坐标范围有重叠则进行合并，并使用重叠区域替代当前区域
        int res = 1;
        for (int i = 1; i < n; i++) {
            // 区域重叠
            if (points[i][0] <= points[i - 1][1]) {
                points[i][1] = Math.min(points[i][1], points[i - 1][1]);
            } else {
                // 不重叠
                res++;
            }
        }
        return res;
    }
}