算法分析之贪心算法
算法相关数据结构总结：
| 序号 | 数据结构 | 文章 |
|---|---|---|
| 1 | 动态规划 | 动态规划之背包问题——01背包 动态规划之背包问题——完全背包 动态规划之打家劫舍系列问题 动态规划之股票买卖系列问题 动态规划之子序列问题 算法（Java）——动态规划 |
| 2 | 数组 | 算法分析之数组问题 |
| 3 | 链表 | 算法分析之链表问题 算法（Java）——链表 |
| 4 | 二叉树 | 算法分析之二叉树 算法分析之二叉树遍历 算法分析之二叉树常见问题 算法（Java）——二叉树 |
| 5 | 哈希表 | 算法分析之哈希表 算法（Java）——HashMap、HashSet、ArrayList |
| 6 | 字符串 | 算法分析之字符串 算法（Java）——字符串String |
| 7 | 栈和队列 | 算法分析之栈和队列 算法（Java）——栈、队列、堆 |
| 8 | 贪心算法 | 算法分析之贪心算法 |
| 9 | 回溯 | Java实现回溯算法入门（排列+组合+子集） Java实现回溯算法进阶（搜索） |
| 10 | 二分查找 | 算法（Java）——二分法查找 |
| 11 | 双指针、滑动窗口 | 算法（Java）——双指针 算法分析之滑动窗口类问题 |
文章目录
-
-
- 一、贪心算法基础知识
-
- 1. 基本概念
- 2. 基本思路
- 3. 存在问题
- 4. 适用问题
- 5. 贪心选择性质与最优子结构性质
- 6. 实现框架
- 二、贪心算法与动态规划
-
- 1. 举例分析
-
- 1）0-1背包问题
- 2）背包问题
- 2. 贪心套路
- 三、leetcode例题讲解贪心算法问题
-
- 1. 贪心算法常规问题
-
- （1）常规问题
-
- 455. 分发饼干
- 1005. K 次取反后最大化的数组和
- 860. 柠檬水找零
- 2. 贪心算法进阶问题
-
- （1）序列问题
-
- 376. 摆动序列
- 738. 单调递增的数字
- （2）股票问题
-
- 122. 买卖股票的最佳时机 II
- 714. 买卖股票的最佳时机含手续费
- （3）两个维度权衡问题
-
- 135. 分发糖果
- 406. 根据身高重建队列
- 3. 贪心算法难度问题
-
- （1）区间问题
-
- 55. 跳跃游戏
- 45. 跳跃游戏 II
- 452. 用最少数量的箭引爆气球
- 435. 无重叠区间
- 763. 划分字母区间
- 56. 合并区间
- （2）一般问题
-
- 53. 最大子数组和
- 134. 加油站
- 968. 监控二叉树
-
一、贪心算法基础知识
1. 基本概念
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。
贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。必须注意的是，贪心算法不是对所有问题都能得到整体最优解，选择的贪心策略必须具备无后效性（即某个状态以后的过程不会影响以前的状态，只与当前状态有关。）
2. 基本思路
- 建立数学模型来描述问题。
- 把求解的问题分成若干个子问题。
- 对每一子问题求解，得到子问题的局部最优解。
- 把子问题的解局部最优解合成原来解问题的一个解。
3. 存在问题
-
不能保证求得的最后解是最佳的；
-
不能用来求最大或最小解问题；
-
只能求满足某些约束条件的可行解的范围。
4. 适用问题
贪心策略适用的前提是：局部最优策略能导致产生全局最优解。
实际上，贪心算法适用的情况很少。一般对一个问题分析是否适用于贪心算法，可以先选择该问题下的几个实际数据进行分析，就可以做出判断。
5. 贪心选择性质与最优子结构性质
对于一个具体的问题，怎么知道是否可用贪心算法解此问题，以及能否得到问题的最优解呢? 这个问题很难给予肯定的回答。
但是，从许多可以用贪心算法求解的问题中看到这类问题一般具有2个重要的性质：贪心选择性质和最优子结构性质。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，换句话说，当考虑做何种选择的时候，我们只考虑对当前问题最佳的选择而不考虑子问题的结果。这是贪心算法可行的第一个基本要素。
贪心算法以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。
对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。
当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用贪心算法求解的关键特征。
6. 实现框架
从问题的某一初始解出发：
while (朝给定总目标前进一步)
{
利用可行的决策，求出可行解的一个解元素。
}
由所有解元素组合成问题的一个可行解；
二、贪心算法与动态规划
贪心算法和动态规划算法都要求问题具有最优子结构性质，这是2类算法的一个共同点。但是，对于具有最优子结构的问题应该选用贪心算法还是动态规划算法求解?是否能用动态规划算法求解的问题也能用贪心算法求解?
贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
这么说有点抽象，来举一个例子：
例如，有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？
指定每次拿最大的，最终结果就是拿走最大数额的钱。
每次拿最大的就是局部最优，最后拿走最大数额的钱就是推出全局最优。
再举一个例子如果是 有一堆盒子，你有一个背包体积为n，如何把背包尽可能装满，如果还每次选最大的盒子，就不行了。这时候就需要动态规划。
如何验证可不可以用贪心算法呢？
最好用的策略就是举反例，如果想不到反例，那么就试一试贪心吧。
可有有同学认为手动模拟，举例子得出的结论不靠谱，想要严格的数学证明。
一般数学证明有如下两种方法：
- 数学归纳法
- 反证法
1. 举例分析
下面研究 2 个经典的组合优化问题，并以此说明贪心算法与动态规划算法的主要差别。
1）0-1背包问题
给定n种物品和一个背包。物品i的重量是Wi，其价值为Vi，背包的容量为C。应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
在选择装入背包的物品时，对每种物品i只有2种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。
2）背包问题
与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，1 <= i <= n。
这 2 类问题都具有最优子结构性质，极为相似，但背包问题可以用贪心算法求解，而0-1背包问题却不能用贪心算法求解。
用贪心算法解背包问题的基本步骤：
首先计算每种物品单位重量的价值Vi/Wi，然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后，背包内的物品总重量未超过C，则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去，直到背包装满为止。
不能用贪心算法解0-1背包问题：
对于0-1背包问题，贪心选择之所以不能得到最优解是因为在这种情况下，它无法保证最终能将背包装满，部分闲置的背包空间使每公斤背包空间的价值降低了。事实上，在考虑0-1背包问题时，应比较选择该物品和不选择该物品所导致的最终方案，然后再作出最好选择。由此就导出许多互相重叠的子问题。这正是该问题可用动态规划算法求解的另一重要特征。实际上也是如此，动态规划算法的确可以有效地解0-1背包问题。可以参考：动态规划之背包问题——01背包。
2. 贪心套路
总之，贪心没有套路，说白了就是常识性推导加上举反例。
三、leetcode例题讲解贪心算法问题
1. 贪心算法常规问题
（1）常规问题
455. 分发饼干
leetcode题目链接：455. 分发饼干
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
示例一：
输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。
示例二：
输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.
解题思路：
局部最优就是小饼干喂给小胃口的。
然后用一个index来控制饼干数组的遍历，遍历饼干并没有再起一个for循环，而是采用自减的方式，这也是常用的技巧。
Java代码实现：
class Solution {
public int findContentChildren(int[] g, int[] s) {
// 贪心，用尽量小的饼干满足小胃口的学生
Arrays.sort(g);
Arrays.sort(s);
int res = 0;
int start = 0;
// 遍历每一块饼干，对每一个学生，小饼干喂小学生
for(int i = 0; i < s.length && start < g.length; i++) {
if(s[i] >= g[start]) {
start++;
res++;
}
}
return res;
}
}
1005. K 次取反后最大化的数组和
leetcode题目链接：1005. K 次取反后最大化的数组和
给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
- 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
以这种方式修改数组后，返回数组 可能的最大和 。
示例一：
输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。
示例二：
输入：nums = [3,-1,0,2], k = 3
输出：6
解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。
解题思路：
贪心的思路，局部最优：让绝对值大的负数变为正数，当前数值达到最大，整体最优：整个数组和达到最大。
局部最优可以推出全局最优。
那么如果将负数都转变为正数了，K依然大于0，此时的问题是一个有序正整数序列，如何转变K次正负，让 数组和 达到最大。
那么又是一个贪心：局部最优：只找数值最小的正整数进行反转，当前数值可以达到最大（例如正整数数组{5, 3, 1}，反转1 得到-1 比 反转5得到的-5 大多了），全局最优：整个 数组和 达到最大。
那么本题的解题步骤为：
- 第一步：将数组大小从小到大排序
- 第二步：从前向后遍历，遇到负数将其变为正数，同时K–
- 第三步：如果K还大于0，那么就把负数反过来，将K用完
- 第四步：求和
Java代码实现：
class Solution {
public int largestSumAfterKNegations(int[] nums, int k) {
// 排序，把可能有的负数排到前面
Arrays.sort(nums);
int sum = 0;
for (int i = 0; i < nums.length; i++) {
// 贪心：如果是负数，而k还有盈余，就把负数反过来
if (nums[i] < 0 && k > 0) {
nums[i] = -1 * nums[i];
k--;
}
sum += nums[i];
}
Arrays.sort(nums);
// 如果k没剩，那说明能转的负数都转正了，已经是最大和，返回sum
// 如果k有剩，说明负数已经全部转正，所以如果k还剩偶数个就自己抵消掉，不用删减，如果k还剩奇数个就减掉2倍最小正数。
return sum - (k % 2 == 0 ? 0 : 2 * nums[0]);
}
}
860. 柠檬水找零
leetcode题目链接：860. 柠檬水找零
在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
注意，一开始你手头没有任何零钱。
给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
示例一：
输入：bills = [5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。
示例二：
输入：bills = [5,5,10,10,20]
输出：false
解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false。
解题思路：
只需要维护三种金额的数量，5，10和20。
有如下三种情况：
- 情况一：账单是5，直接收下。
- 情况二：账单是10，消耗一个5，增加一个10
- 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5
此时大家就发现 情况一，情况二，都是固定策略，都不用我们来做分析了，而唯一不确定的其实在情况三。
情况三这里是有贪心的。
账单是20的情况，为什么要优先消耗一个10和一个5呢？
因为美元10只能给账单20找零，而美元5可以给账单10和账单20找零，美元5更万能！
所以局部最优：遇到账单20，优先消耗美元10，完成本次找零。全局最优：完成全部账单的找零。
局部最优可以推出全局最优，并找不出反例，那么就试试贪心算法！
Java代码实现：
class Solution {
public boolean lemonadeChange(int[] bills) {
int numFive = 0;
int numTen = 0;
for(int i = 0; i < bills.length; i++) {
if(bills[i] == 5) {
numFive++;
} else if(bills[i] == 10) {
numFive--;
numTen++;
} else if(bills[i] == 20) { // 当20元时贪心，每次先找零10和5，没有再找3个5
if(numTen > 0) {
numTen--;
numFive--;
} else{
numFive -= 3;
}
}
if(numFive < 0 || numTen < 0) return false;
}
return true;
}
}
2. 贪心算法进阶问题
（1）序列问题
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 中作为 摆动序列 的 最长子序列的长度 。
示例一：
输入：nums = [1,7,4,9,2,5]
输出：6
解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。
解题思路：
局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。
整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。
实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计数组的峰值数量就可以了（相当于是删除单一坡度上的节点，然后统计长度）
这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点。
本题代码实现中，还有一些技巧，例如统计峰值的时候，数组最左面和最右面是最不好统计的。
例如序列[2,5]，它的峰值数量是2，如果靠统计差值来计算峰值个数就需要考虑数组最左面和最右面的特殊情况。
所以可以针对序列[2,5]，可以假设为[2,2,5]，这样它就有坡度了即preDiff = 0，如图：
针对以上情形，result初始为1（默认最右面有一个峰值），此时curDiff > 0 && preDiff <= 0，那么result++（计算了左面的峰值），最后得到的result就是2（峰值个数为2即摆动序列长度为2）
Java代码实现：
- 贪心
class Solution {
public int wiggleMaxLength(int[] nums) {
int n = nums.length;
if(n < 2) return n;
// 贪心算法，保持区间波动，只需要把单调区间上的元素移除就可以了
// 当前差值
int curDiff = 0;
// 上一个插值
int preDiff = 0;
int count = 1;
for(int i = 1; i < n; i++){
// 得到当前差值
curDiff = nums[i] - nums[i-1];
//如果当前差值和上一个差值为一正一负
//等于0的情况表示初始时的preDiff,将当前差值赋值给前差值，继续判断
if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
count++;
preDiff = curDiff;
}
}
return count;
}
}
- 动态规划
class Solution {
public int wiggleMaxLength(int[] nums) {
// 动态规划，分别统计递增的元素个数和递减的元素个数，比较大小
// up[i] 表示以前 i 个元素中的某一个为结尾的最长的「上升摆动序列」的长度。
// down[i]表示以前 i 个元素中的某一个为结尾的最长的「下降摆动序列」的长度。
int n = nums.length;
if(n < 2) return n;
// 原始动态规划
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[i] = Math.max(up[i - 1], down[i - 1] + 1);
down[i] = down[i - 1];
} else if (nums[i] < nums[i - 1]) {
up[i] = up[i - 1];
down[i] = Math.max(up[i - 1] + 1, down[i - 1]);
} else {
up[i] = up[i - 1];
down[i] = down[i - 1];
}
}
return Math.max(up[n - 1], down[n - 1]);
// // 优化动态规划，直接用up和down减少变量存储
// int up = 1, down = 1;
// for(int i = 1; i < n; i++){
// if(nums[i] > nums[i-1]) {
// up = down + 1;
// }
// if(nums[i] < nums[i-1]) {
// down = up + 1;
// }
// }
// return Math.max(up, down);
}
}
738. 单调递增的数字
leetcode题目链接：738. 单调递增的数字
给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）
示例一：
输入: N = 10
输出: 9
示例二：
输入: N = 332
输出: 299
解题思路：
题目要求小于等于N的最大单调递增的整数，那么拿一个两位的数字来举例。
例如：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。
从后向前遍历，就可以重复利用上次比较得出的结果了，从后向前遍历332的数值变化为：332 -> 329 -> 299。
Java代码实现：
class Solution {
public int monotoneIncreasingDigits(int n) {
String s = String.valueOf(n);
int len = s.length();
char[] ch = s.toCharArray();
int flag = len; // 用来标记赋值为9的下标
for(int i = len - 1; i >= 1; i--) {
// 从后向前遍历，一旦出现ch[i - 1] > ch[i]的情况（非单调递增），首先想让ch[i - 1]减一，ch[i]赋值9
if(ch[i] < ch[i - 1]) {
flag = i;
ch[i - 1]--;
}
}
for(int i = flag; i < len; i++) {
ch[i] = '9';
}
return Integer.parseInt(new String(ch));
}
}
（2）股票问题
122. 买卖股票的最佳时机 II
leetcode题目链接：122. 买卖股票的最佳时机 II
给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例一：
输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
解题思路：
其实最终利润是可以分解的，那么本题就很容易了！
如何分解呢？
假如第0天买入，第3天卖出，那么利润为：prices[3] - prices[0]。
相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。
此时就是把利润分解为每天为单位的维度，而不是从0天到第3天整体去考虑！
那么根据prices可以得到每天的利润序列：(prices[i] - prices[i - 1])…(prices[1] - prices[0])。
Java代码实现：
- 贪心
class Solution {
public int maxProfit(int[] prices) {
// 1.贪心算法，只要后一天比前一天大，就把差值加一下
int res = 0;
for(int i = 1; i < prices.length; i++){
if(prices[i] > prices[i-1]){
res += prices[i] - prices[i-1];
}
}
return res;
}
}
- 动态规划
class Solution {
public int maxProfit(int[] prices) {
int[][] dp = new int[prices.length][2];
dp[0][0] = - prices[0];
dp[0][1] = 0;
for(int i = 1; i < prices.length; i++){
dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] - prices[i]);
dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] + prices[i]);
}
return dp[prices.length-1][1];
}
}
动态规划的解法可参考：动态规划之股票买卖系列问题。
714. 买卖股票的最佳时机含手续费
leetcode题目链接：714. 买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
示例一：
输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8
解题思路：
本题有了手续费，就要关系什么时候买卖了，因为计算所获得利润，需要考虑买卖利润可能不足以手续费的情况。
如果使用贪心策略，就是最低值买，最高值（如果算上手续费还盈利）就卖。
此时无非就是要找到两个点，买入日期，和卖出日期。
- 买入日期：其实很好想，遇到更低点就记录一下。
- 卖出日期：这个就不好算了，但也没有必要算出准确的卖出日期，只要当前价格大于（最低价格+手续费），就可以收获利润，至于准确的卖出日期，就是连续收获利润区间里的最后一天（并不需要计算是具体哪一天）。
所以我们在做收获利润操作的时候其实有三种情况：
- 情况一：收获利润的这一天并不是收获利润区间里的最后一天（不是真正的卖出，相当于持有股票），所以后面要继续收获利润。
- 情况二：前一天是收获利润区间里的最后一天（相当于真正的卖出了），今天要重新记录最小价格了。
- 情况三：不作操作，保持原有状态（买入，卖出，不买不卖）。
Java代码实现：
- 贪心
class Solution {
public int maxProfit(int[] prices, int fee) {
// 贪心算法，
int n = prices.length;
int buy = prices[0] + fee;
int profit = 0;
for (int i = 1; i < n; ++i) {
if (prices[i] + fee < buy) {
buy = prices[i] + fee;
} else if (prices[i] > buy) {
profit += prices[i] - buy;
buy = prices[i];
}
}
return profit;
}
}
- 动态规划
class Solution {
public int maxProfit(int[] prices, int fee) {
// 动态规划，含手续费的股票交易
int[][] dp = new int[prices.length][2];
dp[0][0] = 0; // 不持股
dp[0][1] = - prices[0] - fee; // 持股
for(int i = 1; i < prices.length; i++){
dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i] - fee);
}
return dp[prices.length-1][0];
}
}
动态规划的解法可参考：动态规划之股票买卖系列问题。
（3）两个维度权衡问题
135. 分发糖果
leetcode题目链接：135. 分发糖果
老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
你需要按照以下要求，帮助老师给这些孩子分发糖果：
- 每个孩子至少分配到 1 个糖果。
- 评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？
示例一：
输入：[1,0,2]
输出：5
解释：你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例二：
输入：[1,2,2]
输出：4
解释：你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。
解题思路：
这道题目一定是要确定一边之后，再确定另一边，例如比较每一个孩子的左边，然后再比较右边，如果两边一起考虑一定会顾此失彼。
先确定右边评分大于左边的情况（也就是从前向后遍历）
此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果，全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果
局部最优可以推出全局最优。
如果ratings[i] > ratings[i - 1] 那么[i]的糖 一定要比[i - 1]的糖多一个，所以贪心：nums[i] = nums[i - 1] + 1
代码如下：
for(int i = 1; i < ratings.length; i++){
if(ratings[i] > ratings[i - 1]){
nums[i] = nums[i - 1] + 1;
}else {
nums[i] = 1;
}
}
如图：
再确定左孩子大于右孩子的情况（从后向前遍历）
如果前一位比后一位高分并且得到的糖果小于或等于后一位，就给前一位孩子比后一位孩子多1个糖果。
代码如下：
for(int i = ratings.length -2 ; i >= 0; i--){
if(ratings[i] > ratings[i + 1] && nums[i] <= nums[i + 1]){
nums[i] = nums[i + 1] + 1;
}
}
Java代码实现：
class Solution {
public int candy(int[] ratings) {
if(ratings == null || ratings.length == 0){
return 0;
}
int[] nums = new int[ratings.length]; //记录每一位孩子得到的糖果数
nums[0] = 1;
// 先正序遍历，如果后一位比前一位高分，就给比前一位多1个糖果，否则给1
for(int i = 1; i < ratings.length; i++){
if(ratings[i] > ratings[i - 1]){
nums[i] = nums[i - 1] + 1;
}else {
nums[i] = 1;
}
}
// 再倒序遍历，如果前一位比后一位高分并且得到的糖果小于或等于后一位，就给前一位孩子比后一位孩子多1个糖果
for(int i = ratings.length -2 ; i >= 0; i--){
if(ratings[i] > ratings[i + 1] && nums[i] <= nums[i + 1]){
nums[i] = nums[i + 1] + 1;
}
}
int count = 0;
for(int i : nums){
count += i;
}
return count;
}
}
406. 根据身高重建队列
leetcode题目链接：406. 根据身高重建队列
假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。
请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。
示例一：
输入：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]] 是重新构造后的队列。
解题思路：
本题有两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后在按照另一个维度重新排列。
如果两个维度一起考虑一定会顾此失彼。
对于本题相信大家困惑的点是先确定k还是先确定h呢，也就是究竟先按h排序呢，还先按照k排序呢？
如果按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件，两个维度哪一个都没确定下来。
那么按照身高h来排序呢，身高一定是从大到小排（身高相同的话则k小的站前面），让高个子在前面。
此时我们可以确定一个维度了，就是身高，前面的节点一定都比本节点高！
那么只需要按照k为下标重新插入队列就可以了，为什么呢？
以图中{5,2} 为例：
按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。
所以在按照身高从大到小排序后：
局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性
全局最优：最后都做完插入操作，整个队列满足题目队列属性
Java代码实现：
class Solution {
public int[][] reconstructQueue(int[][] people) {
// 身高从大到小排（身高相同k小的站前面）
Arrays.sort(people, (a, b) -> {
if (a[0] == b[0]) return a[1] - b[1];
return b[0] - a[0];
});
ArrayList<int[]> queue = new ArrayList<>();
for (int[] p : people) {
// 前面放置过的人，身高肯定比自己高，所以就放在自己对应的k位置即可
// p[1]表示插入的位置即k，p表示插入的值
queue.add(p[1], p);
}
return queue.toArray(new int[people.length][]);
}
}
3. 贪心算法难度问题
（1）区间问题
55. 跳跃游戏
leetcode题目链接：55. 跳跃游戏
给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。
示例一：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
解题思路：
跳几步无所谓，关键在于可跳的覆盖范围！
不一定非要明确一次究竟跳几步，每次取最大的跳跃步数，这个就是可以跳跃的覆盖范围。
这个范围内，别管是怎么跳的，反正一定可以跳过来。
那么这个问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点！
每次移动取最大跳跃步数（得到最大的覆盖范围），每移动一个单位，就更新最大覆盖范围。
贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。
局部最优推出全局最优，找不出反例，试试贪心！
i每次移动只能在cover的范围内移动，每移动一个元素，cover得到该元素数值（新的覆盖范围）的补充，让i继续移动下去。
而cover每次只取 max(该元素数值补充后的范围, cover本身范围)。
如果cover大于等于了终点下标，直接return true就可以了。
Java实现代码：
class Solution {
public boolean canJump(int[] nums) {
int right = nums[0]; // 存储最远可达到位置
for(int i = 0; i < nums.length; i++){
if(i <= right){
right = Math.max(right, i + nums[i]);
if(right >= nums.length-1){
return true;
}
}
}
return false;
}
}
45. 跳跃游戏 II
leetcode题目链接：45. 跳跃游戏 II
给你一个非负整数数组 nums ，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
假设你总是可以到达数组的最后一个位置。
示例一：
输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
解题思路：
思路是相似的，还是要看最大覆盖范围。
本题要计算最小步数，那么就要想清楚什么时候步数才一定要加一呢？
贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。
真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数！
这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。
如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。
图中覆盖范围的意义在于，只要红色的区域，最多两步一定可以到！（不用管具体怎么跳，反正一定可以跳到）
移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不考虑是不是终点的情况。
想要达到这样的效果，只要让移动下标，最大只能移动到nums.size - 2的地方就可以了。
Java代码实现：
class Solution {
public int jump(int[] nums) {
int length = nums.length;
int end = 0; // 当前覆盖的最远距离下标
int maxPosition = 0; // 下一步覆盖的最远距离下标
int steps = 0; // 记录走的最大步数
for (int i = 0; i < length - 1; i++) {
maxPosition = Math.max(maxPosition, i + nums[i]); // 找到所能达到的最远位置
if (i == end) { // end为最远位置，到达则步数加1
end = maxPosition; // 更新当前覆盖的最远距离下标
steps++;
}
}
return steps;
}
}
452. 用最少数量的箭引爆气球
leetcode题目链接：452. 用最少数量的箭引爆气球
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。
一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。
给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。
示例一：
输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球
解题思路：
题目臭长，还不清楚。
局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。
如果把气球排序之后，从前到后遍历气球，被射过的气球仅仅跳过就行了，没有必要让气球数组remote气球，只要记录一下箭的数量就可以了。
以上为思考过程，已经确定下来使用贪心了，那么开始解题。
为了让气球尽可能的重叠，需要对数组进行排序。
那么按照气球起始位置排序，还是按照气球终止位置排序呢？
其实都可以！只不过对应的遍历顺序不同，我就按照气球的起始位置排序了。
既然按照起始位置排序，那么就从前向后遍历气球数组，靠左尽可能让气球重复。
从前向后遍历遇到重叠的气球了怎么办？
如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。
以题目示例： [[10,16],[2,8],[1,6],[7,12]]为例，如图：（方便起见，已经排序）
可以看出首先第一组重叠气球，一定是需要一个箭，气球3，的左边界大于了 第一组重叠气球的最小右边界，所以再需要一支箭来射气球3了。
Java实现代码：
class Solution {
public int findMinArrowShots(int[][] points) {
// 贪心，每个气球至少需要一支箭，先按右端点排序，每次从最小的右端点射箭，去掉被射爆的气球
if(points.length == 0) return 0;
// 排序，要用compare，用a-b会溢出
Arrays.sort(points, (o1, o2) -> Integer.compare(o1[1], o2[1]));
int count = 1;
int index = points[0][1]; // 存储最小的右端点
for(int i = 1; i < points.length; i++) {
if(index < points[i][0]) { // 若和气球的起始点没有重叠,则箭数加1，修改最小的右端点
count++;
index = points[i][1];
}
}
return count;
}
}
435. 无重叠区间
leetcode题目链接：435. 无重叠区间
给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。
注意:
- 可以认为区间的终点总是大于它的起点。
- 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
示例一：
输入: [ [1,2], [2,3], [3,4], [1,3] ]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。
解题思路：
按照右边界排序，从左向右记录非交叉区间的个数。最后用区间总数减去非交叉区间的个数就是需要移除的区间个数了。
此时问题就是要求非交叉区间的最大个数。
右边界排序之后，局部最优：优先选右边界小的区间，所以从左向右遍历，留给下一个区间的空间大一些，从而尽量避免交叉。全局最优：选取最多的非交叉区间。
局部最优推出全局最优，试试贪心！
这里记录非交叉区间的个数还是有技巧的，如图：
区间，1，2，3，4，5，6都按照右边界排好序。
每次取非交叉区间的时候，都是可右边界最小的来做分割点（这样留给下一个区间的空间就越大），所以第一条分割线就是区间1结束的位置。
接下来就是找大于区间1结束位置的区间，是从区间4开始。
区间4结束之后，在找到区间6，所以一共记录非交叉区间的个数是三个。
总共区间个数为6，减去非交叉区间的个数3。移除区间的最小数量就是3。
Java代码实现：
class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
// 贪心算法，找最大可组成的不重叠区间
if(intervals.length < 2) return 0;
// 排序，按右边界最小排序
Arrays.sort(intervals, (a, b) -> Integer.compare(a[1], b[1]));
int count = 1;
int end = intervals[0][1];
for(int i = 1; i < intervals.length; i++) {
if(end <= intervals[i][0]) { // 若没有重叠
count++;
end = intervals[i][1];
}
}
return intervals.length - count;
}
}
763. 划分字母区间
leetcode题目链接：763. 划分字母区间
字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。
示例一：
输入：S = "ababcbacadefegdehijhklij"
输出：[9,7,8]
解释：
划分结果为 "ababcbaca", "defegde", "hijhklij"。
每个字母最多出现在一个片段中。
像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。
解题思路：
在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。
可以分为如下两步：
- 统计每一个字符最后出现的位置
- 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点
Java代码实现：
class Solution {
public List<Integer> partitionLabels(String s) {
// 贪心，统计每一个字符的边界
// 从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点
List<Integer> list = new LinkedList<>();
int[] ch = new int[26];
char[] c = s.toCharArray();
for(int i = 0; i < c.length; i++) {
ch[c[i] - 'a'] = i;
}
int index = 0;
int last = -1;
for(int i = 0; i < c.length; i++) {
index = Math.max(index, ch[c[i] - 'a']);
if(i == index) {
list.add(i - last);
last = i;
}
}
return list;
}
}
56. 合并区间
leetcode题目链接：56. 合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
示例一：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
解题思路：
按照左边界排序，排序之后
局部最优：每次合并都取最大的右边界，这样就可以合并更多的区间了，
整体最优：合并所有重叠的区间。
局部最优可以推出全局最优，找不出反例，试试贪心。
按照左边界从小到大排序之后，如果 intervals[i][0] < intervals[i - 1][1] 即intervals[i]左边界 < intervals[i - 1]右边界，则一定有重复，因为intervals[i]的左边界一定是大于等于intervals[i - 1]的左边界。
即：intervals[i]的左边界在intervals[i - 1]左边界和右边界的范围内，那么一定有重复！
判断重复之后，剩下的就是合并了，如何去模拟合并区间呢？
其实就是用合并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。如果没有合并就把原区间加入到result数组。
Java实现代码：
class Solution {
public int[][] merge(int[][] intervals) {
List<int[]> res = new LinkedList<>();
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
int start = intervals[0][0]; // 第一个左边边界
for(int i = 1; i < intervals.length; i++) {
if(intervals[i][0] > intervals[i - 1][1]){ // 左边界大于上一个的右边界，则无重叠，还保存原来的
res.add(new int[]{start, intervals[i - 1][1]});
start = intervals[i][0];
} else { // 左边界到重叠右边界，右边界就变为最大的右边界
intervals[i][1] = Math.max(intervals[i][1], intervals[i - 1][1]);
}
}
res.add(new int[]{start, intervals[intervals.length - 1][1]}); // 加入最后一个区间
return res.toArray(new int[res.size()][]);
}
}
（2）一般问题
53. 最大子数组和
leetcode题目链接：53. 最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
示例一：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
解题思路：
局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。
全局最优：选取最大“连续和”
局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。
从代码角度上来讲：遍历nums，从头开始用count累积，如果count一旦加上nums[i]变为负数，那么就应该从nums[i+1]开始从0累积count了，因为已经变为负数的count，只会拖累总和。
区间的终止位置，其实就是如果count取到最大值了，及时记录下来了。例如如下代码：
if (count > result) result = count;
这样相当于是用result记录最大子序和区间和（变相的算是调整了终止位置）。
Java代码实现：
- 贪心
class Solution {
public int maxSubArray(int[] nums) {
// 贪心
int res = Integer.MIN_VALUE; // 记载最大和
int sum = 0; // 记载区间和
for(int i = 0; i < nums.length; i++) {
sum += nums[i];
res = Math.max(sum, res); // 取区间累计的最大值
if(sum < 0) sum = 0; // 如果sum < 0, 重新开始找
}
return res;
}
}
- 动态规划
class Solution {
public int maxSubArray(int[] nums) {
int res = nums[0]; //存储和的最大值
for(int i = 1; i < nums.length; i++){
nums[i] += Math.max(nums[i-1], 0);
res = Math.max(res, nums[i]);
}
return res;
}
}
动态规划的详细分析请参考：动态规划之子序列问题。
134. 加油站
leetcode题目链接：134. 加油站
在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。
说明:
- 如果题目有解，该答案即为唯一答案。
- 输入数组均为非空数组，且长度相同。
- 输入数组中的元素均为非负数。
示例一：
输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。
解题思路：
首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。
每个加油站的剩余量rest[i]为gas[i] - cost[i]。
i从0开始累加rest[i]，和记为rest，一旦rest小于零，说明[0, i]区间都不能作为起始位置，起始位置从i+1算起，再从0计算rest。
那么局部最优：当前累加rest[j]的和rest一旦小于0，起始位置至少要是j+1，因为从j开始一定不行。全局最优：找到可以跑一圈的起始位置。
Java代码实现：
class Solution {
public int canCompleteCircuit(int[] gas, int[] cost) {
int rest = 0; // 每个加油站剩余油量
int total = 0; // 总剩余量
int index = 0; // 出发加油站编号
for(int i = 0; i < gas.length; i++) {
rest += gas[i] - cost[i];
total += gas[i] - cost[i];
if(rest < 0) {
index = i + 1;
rest = 0;
}
}
if(total < 0) return -1;
return index;
}
}
968. 监控二叉树
leetcode题目链接：968. 监控二叉树
给定一个二叉树，我们在树的节点上安装摄像头。
节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
计算监控树的所有节点所需的最小摄像头数量。
示例一：
输入：[0,0,null,0,0]
输出：1
解释：如图所示，一台摄像头足以监控所有节点。
解题思路：
从题目中示例，其实可以得到启发，我们发现题目示例中的摄像头都没有放在叶子节点上！
这是很重要的一个线索，摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。
所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。
那么有同学可能问了，为什么不从头结点开始看起呢，为啥要从叶子节点看呢？
因为头结点放不放摄像头也就省下一个摄像头， 叶子节点放不放摄像头省下了的摄像头数量是指数阶别的。
所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！
此时这道题目还有两个难点：
- 二叉树的遍历
- 如何隔两个节点放一个摄像头
确定遍历顺序：
可以使用后序遍历也就是左右根的顺序，这样就可以在回溯的过程中从下到上进行推导了。
如何隔两个节点放一个摄像头：
我们分别有三个数字来表示节点的状态：
- 0：该节点无覆盖
- 1：覆盖到了，无摄像头
- 2：覆盖到了，有摄像头
以下就是遇到的各种情况：
情况一：空节点，当作覆盖到了
if(root == null) return 1;
情况二：叶节点，贪心的策略：使用其父节点放置摄像头，能覆盖更多的节点
if(root.left == null && root.right == null) return 0;
后序遍历，左右节点
情况三：左右子节点有一个无覆盖，则装一个摄像头
if(left == 0 || right == 0) {
count++;
return 2;
}
情况四：左右子节点有一个放置摄像头，此处不需要重复放置，已经被覆盖
if(left == 2 || right == 2) {
return 1;
}
情况五：子节点都被覆盖，但没有摄像头，因此当前点没有覆盖
return 0;
Java代码实现：
class Solution {
int count = 0;
public int minCameraCover(TreeNode root) {
if(cover(root) == 0) count++;
return count;
}
public int cover(TreeNode root) {
// 状态设置：0.表示本节点无覆盖 1.覆盖到了，无摄像头 2.覆盖到了，有摄像头
// 空节点，当作覆盖到了
if(root == null) return 1;
// 叶节点，贪心的策略：使用其父节点放置摄像头，能覆盖更多的节点
if(root.left == null && root.right == null) return 0;
// 后序遍历
int left = cover(root.left);
int right = cover(root.right);
// 左右子节点有一个无覆盖，则装一个摄像头
if(left == 0 || right == 0) {
count++;
return 2;
}
// 左右子节点有一个放置摄像头，此处不需要重复放置，已经被覆盖
if(left == 2 || right == 2) {
return 1;
}
// 子节点都被覆盖，但没有摄像头，因此当前点没有覆盖
return 0;
}
}
参考：
五大常用算法之一：贪心算法
五大常用算法——贪心算法详解及经典例子
贪心算法
代码随想录：贪心算法