贪心算法基础
1、什么是贪心
贪心的本质是选择每一阶段的局部最优,从而达到全局最优。
2、 贪心一般解题步骤
贪心算法一般分为如下四步:
- 将问题分解为若干个子问题
- 找出适合的贪心策略
- 求解每一个子问题的最优解
- 将局部最优解堆叠成全局最优解
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。
思路:
为了满足更多的小孩,就不要造成饼干尺寸的浪费。
大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子,那么就应该优先满足胃口大的。
这里的局部最优就是大饼干喂给胃口大的,充分利用饼干尺寸喂饱一个,全局最优就是喂饱尽可能多的小孩。
可以尝试使用贪心策略,先将饼干数组和小孩数组排序。
然后从后向前遍历小孩数组,用大饼干优先满足胃口大的,并统计满足小孩数量。
如图:
package com.yzu.lee.greedy;
import java.util.Arrays;
/**
* @ClassName: FindContentChildren
* @Description:假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。 对每个孩子 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。
* @author: Leekuangyew
* @date: 2022/6/9 20:26
*/
public class FindContentChildren {
public int findContentChildren(int[] g, int[] s) {
//将最大的饼干先喂饱大胃口
Arrays.sort(g);
Arrays.sort(s);
int result = 0;
int j = s.length - 1;
//遍历胃口
for (int i = g.length - 1; i >= 0; i--) {
if (j >= 0 && s[j] >= g[i]) {
result++;
j--;
}
}
return result;
}
}
376. 摆动序列
如果连续数字之间的差严格地在正数和负数之间交替,则数字序列称为摆动序列。第一个差(如果存在的话)可能是正数或负数。少于两个元素的序列也是摆动序列。
例如, [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
- 解释: 整个序列均为摆动序列。
package com.yzu.lee.greedy;
/**
* @ClassName: WiggleMaxLength
* @Description:
* @author: Leekuangyew
* @date: 2022/6/10 8:52
*/
public class WiggleMaxLength {
public int wiggleMaxLength(int[] nums) {
if (nums.length < 2) return nums.length;
//当前差值
int curDiff = 0;
//前一个插值
int preDiff = 0;
//结果
int count = 1;
for (int i = 1; i < nums.length; i++) {
curDiff = nums[i] - nums[i - 1];
if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
count++;
preDiff = curDiff;
}
}
return count;
}
}
53. 最大子序和
给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
示例: 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
package com.yzu.lee.greedy;
/**
* @ClassName: MaxSubArray
* @Description:给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
* 示例: 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
* @author: Leekuangyew
* @date: 2022/6/10 8:58
*/
public class MaxSubArray {
public int maxSubArray(int[] nums) {
//记录最大值
int result = Integer.MIN_VALUE;
//记录一段区间的值
int count = 0;
for (int i = 0; i < nums.length; i++) {
count += nums[i];
result = Integer.max(count, result);
if (count < 0) {
count = 0;
}
}
return result;
}
}
122.买卖股票的最佳时机II
给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。
注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。
示例 1:
- 输入: [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])。
如图:
package com.yzu.lee.greedy;
/**
* @ClassName: MaxProfit
* @Description:给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格。
* 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。
* 注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。
* @author: Leekuangyew
* @date: 2022/6/10 9:51
*/
public class MaxProfit {
public int maxProfit(int[] prices) {
int[] profit = new int[prices.length];
profit[0] = 0;
int result = 0;
for (int i = 1; i < prices.length; i++) {
//如果后一天减去前一天的价格大于等于0 则进行依次买入卖出 ,计算利润
if (prices[i] - prices[i - 1] >= 0) result += prices[i] - prices[i - 1];
}
return result;
}
}
55. 跳跃游戏
给定一个非负整数数组,你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
- 输入: [2,3,1,1,4]
- 输出: true
- 解释: 我们可以先跳 1 步,从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
刚看到本题一开始可能想:当前位置元素如果是3,我究竟是跳一步呢,还是两步呢,还是三步呢,究竟跳几步才是最优呢?
其实跳几步无所谓,关键在于可跳的覆盖范围!
不一定非要明确一次究竟跳几步,每次取最大的跳跃步数,这个就是可以跳跃的覆盖范围。
这个范围内,别管是怎么跳的,反正一定可以跳过来。
那么这个问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点!
每次移动取最大跳跃步数(得到最大的覆盖范围),每移动一个单位,就更新最大覆盖范围。
贪心算法局部最优解:每次取最大跳跃步数(取最大覆盖范围),整体最优解:最后得到整体最大覆盖范围,看是否能到终点。
局部最优推出全局最优,找不出反例,试试贪心!
如图:
package com.yzu.lee.greedy;
/**
* @ClassName: CanJump
* @Description:给定一个非负整数数组,你最初位于数组的第一个位置。 数组中的每个元素代表你在该位置可以跳跃的最大长度。
* 判断你是否能够到达最后一个位置。
* @author: Leekuangyew
* @date: 2022/6/10 10:04
*/
public class CanJump {
public boolean canJump(int[] nums) {
if (nums.length == 1) return true;
//覆盖的最大范围
int cover = 0;
for (int i = 0; i <= cover; i++) {
cover = Integer.max(i + nums[i], cover);
if (cover >= nums.length - 1) return true;
}
return false;
}
}
45.跳跃游戏II
给定一个非负整数数组,你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
示例:
- 输入: [2,3,1,1,4]
- 输出: 2
- 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。
说明: 假设你总是可以到达数组的最后一个位置。
package com.yzu.lee.greedy;
/**
* @ClassName: Jump
* @Description:给定一个非负整数数组,你最初位于数组的第一个位置。 数组中的每个元素代表你在该位置可以跳跃的最大长度。
* 你的目标是使用最少的跳跃次数到达数组的最后一个位置。
* @author: Leekuangyew
* @date: 2022/6/10 10:39
*/
public class Jump {
public int jump(int[] nums) {
if (nums.length == 1) return 0;
//记录走的最大步数
int result = 0;
//当前覆盖的最远距离下标
int maxDir = 0;
//下一步的最远距离下标
int nextDir = 0;
for (int i = 0; i <= maxDir && i < nums.length - 1; i++) {
nextDir = Integer.max(nextDir, i + nums[i]);
if (i == maxDir) {
result++;
maxDir = nextDir;
}
}
return result;
}
}
1005.K次取反后最大化的数组和
给定一个整数数组 A,我们只能用以下方法修改该数组:我们选择某个索引 i 并将 A[i] 替换为 -A[i],然后总共重复这个过程 K 次。(我们可以多次选择同一个索引 i。)
以这种方式修改数组后,返回数组可能的最大和。
示例 1:
- 输入:A = [4,2,3], K = 1
- 输出:5
- 解释:选择索引 (1,) ,然后 A 变为 [4,-2,3]。
package com.yzu.lee.greedy;
import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;
/**
* @ClassName: LargestSumAfterKNegations
* @Description:给定一个整数数组 A,我们只能用以下方法修改该数组:
* 我们选择某个索引 i 并将 A[i] 替换为 -A[i],然后总共重复这个过程 K 次。(我们可以多次选择同一个索引 i。)
* 以这种方式修改数组后,返回数组可能的最大和。
* 示例 1:
* 输入:A = [4,2,3], K = 1
* 输出:5
* 解释:选择索引 (1,) ,然后 A 变为 [4,-2,3]。
* @author: Leekuangyew
* @date: 2022/6/11 14:36
*/
public class LargestSumAfterKNegations {
public int largestSumAfterKNegations(int[] nums, int k) {
//两次贪心
//首先按照绝对值从大到小排序
for (int i = 0; i < nums.length - 1; i++) {
for (int j = 0; j < nums.length - i - 1; j++) {
if (Math.abs(nums[j]) < Math.abs(nums[j + 1])) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
System.out.println(nums);
//翻转绝对值最大的负数
for (int i = 0; i < nums.length; i++) {
if (nums[i] < 0 && k > 0) {
nums[i] = -nums[i];
k--;
}
}
if (k % 2 == 1) nums[nums.length - 1] = -nums[nums.length - 1];
return Arrays.stream(nums).sum();
}
@Test
public void test() {
int[] ints = {2, -3, -1, 5, -4};
largestSumAfterKNegations(ints,2);
}
}
134. 加油站
在一条环路上有 N 个加油站,其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车,从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发,开始时油箱为空。
如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 -1。
说明:
- 如果题目有解,该答案即为唯一答案。
- 输入数组均为非空数组,且长度相同。
- 输入数组中的元素均为非负数。
示例 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],和记为curSum,一旦curSum小于零,说明[0, i]区间都不能作为起始位置,起始位置从i+1算起,再从0计算curSum。
那么为什么一旦[i,j] 区间和为负数,起始位置就可以是j+1呢,j+1后面就不会出现更大的负数?
如果出现更大的负数,就是更新j,那么起始位置又变成新的j+1了。
而且j之前出现了多少负数,j后面就会出现多少正数,因为耗油总和是大于零的(前提我们已经确定了一定可以跑完全程)。
那么局部最优:当前累加rest[j]的和curSum一旦小于0,起始位置至少要是j+1,因为从j开始一定不行。全局最优:找到可以跑一圈的起始位置。
局部最优可以推出全局最优,找不出反例,试试贪心!
package com.yzu.lee.greedy;
/**
* @ClassName: CanCompleteCircuit
* @Description:在一条环路上有 n 个加油站,其中第 i 个加油站有汽油 gas[i] 升。
* 你有一辆油箱容量无限的的汽车,从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。
* 你从其中的一个加油站出发,开始时油箱为空。
* 给定两个整数数组 gas 和 cost ,如果你可以绕环路行驶一周,则返回出发时加油站的编号,否则返回 -1 。如果存在解,则 保证 它是 唯一 的。
* @author: Leekuangyew
* @date: 2022/6/12 16:28
*/
public class CanCompleteCircuit {
public int canCompleteCircuit(int[] gas, int[] cost) {
//当前节点加油到下一个节点的油量
int curSum = 0;
//总油量
int totalSum = 0;
int index = 0;
for (int i = 0; i < gas.length; i++) {
curSum += gas[i] - cost[i];
totalSum += gas[i] - cost[i];
if (curSum < 0) {
index = (i + 1);
curSum = 0;
}
}
return totalSum < 0 ? -1 : index;
}
}
135. 分发糖果
老师想给孩子们分发糖果,有 N 个孩子站成了一条直线,老师会根据每个孩子的表现,预先给他们评分。
你需要按照以下要求,帮助老师给这些孩子分发糖果:
- 每个孩子至少分配到 1 个糖果。
- 相邻的孩子中,评分高的孩子必须获得更多的糖果。
那么这样下来,老师至少需要准备多少颗糖果呢?
示例 1:
- 输入: [1,0,2]
- 输出: 5
- 解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。
package com.yzu.lee.greedy;
import org.junit.Test;
/**
* @ClassName: Candy
* @Description:老师想给孩子们分发糖果,有 N 个孩子站成了一条直线,老师会根据每个孩子的表现,预先给他们评分。
* 你需要按照以下要求,帮助老师给这些孩子分发糖果:
* 每个孩子至少分配到 1 个糖果。
* 相邻的孩子中,评分高的孩子必须获得更多的糖果。
* 那么这样下来,老师至少需要准备多少颗糖果呢?
* @author: Leekuangyew
* @date: 2022/6/13 14:57
*/
public class Candy {
public int candy(int[] ratings) {
//结果数组
int[] result = new int[ratings.length];
result[0] = 1;
//贪心 从左往右遍历 当右孩子大于左孩子时,加一
for (int i = 1; i < ratings.length; i++) {
if (ratings[i] > ratings[i - 1]) result[i] = result[i - 1] + 1;
else result[i] = 1;
}
//贪心 从右往左遍历 当左孩子大于右孩子时,将右孩子的糖果数量+1和左孩子当前糖果值对比 取大的
for (int i = ratings.length - 2; i >= 0; i--) {
if (ratings[i] > ratings[i + 1]) result[i] = Math.max(result[i + 1] + 1, result[i]);
}
//遍历数组
int res = 0;
for (int i = 0; i < result.length; i++) {
res += result[i];
}
return res;
}
@Test
public void test() {
candy(new int[]{1, 2, 2});
}
}
860.柠檬水找零
在柠檬水摊上,每一杯柠檬水的售价为 5 美元。
顾客排队购买你的产品,(按账单 bills 支付的顺序)一次购买一杯。
每位顾客只买一杯柠檬水,然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零,也就是说净交易是每位顾客向你支付 5 美元。
注意,一开始你手头没有任何零钱。
如果你能给每位顾客正确找零,返回 true ,否则返回 false 。
示例 1:
- 输入:[5,5,5,10,20]
- 输出:true
- 解释:
- 前 3 位顾客那里,我们按顺序收取 3 张 5 美元的钞票。
- 第 4 位顾客那里,我们收取一张 10 美元的钞票,并返还 5 美元。
- 第 5 位顾客那里,我们找还一张 10 美元的钞票和一张 5 美元的钞票。
- 由于所有客户都得到了正确的找零,所以我们输出 true。
package com.yzu.lee.greedy;
/**
* @ClassName: LemonadeChange
* @Description:
* @author: Leekuangyew
* @date: 2022/6/13 15:28
*/
public class LemonadeChange {
public boolean lemonadeChange(int[] bills) {
//贪心 主要针对给20块钱 尽可能先找10块+5块的组合
int five = 0, ten = 0, twenty = 0;
for (int bill : bills) {
if (bill == 5) {
five++;
} else if (bill == 10) {
if (five <= 0) return false;
else {
five--;
ten++;
}
} else if (bill == 20) {
if (five > 0 && ten > 0) {
five--;
ten--;
} else if (five >= 3) {
five -= 3;
} else return false;
}
}
return true;
}
}
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]] 是重新构造后的队列。
本题有两个维度,h和k,看到这种题目一定要想如何确定一个维度,然后在按照另一个维度重新排列。
其实如果大家认真做了135. 分发糖果,就会发现和此题有点点的像。遇到两个维度权衡的时候,一定要先确定一个维度,再确定另一个维度。
如果两个维度一起考虑一定会顾此失彼。
对于本题相信大家困惑的点是先确定k还是先确定h呢,也就是究竟先按h排序呢,还先按照k排序呢?
如果按照k来从小到大排序,排完之后,会发现k的排列并不符合条件,身高也不符合条件,两个维度哪一个都没确定下来。
那么按照身高h来排序呢,身高一定是从大到小排(身高相同的话则k小的站前面),让高个子在前面。
此时我们可以确定一个维度了,就是身高,前面的节点一定都比本节点高!
所以在按照身高从大到小排序后:
==局部最优:优先按身高高的people的k来插入。插入操作过后的people满足队列属性==
**全局最优:最后都做完插入操作,整个队列满足题目队列属性**
package com.yzu.lee.greedy;
import org.junit.Test;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
/**
* @ClassName: ReconstructQueue
* @Description:假设有打乱顺序的一群人站成一个队列,数组 people 表示队列中一些人的属性(不一定按顺序)。
* 每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ,前面 正好 有 ki 个身高大于或等于 hi 的人。
* 请你重新构造并返回输入数组 people 所表示的队列。
* 返回的队列应该格式化为数组 queue ,其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性(queue[0] 是排在队列前面的人)。
* @author: Leekuangyew
* @date: 2022/6/13 15:43
*/
public class ReconstructQueue {
public int[][] reconstructQueue(int[][] people) {
//身高从小到大排,(身高相同小的k在前面)
Arrays.sort(people, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
if (o1[0] == o2[0]) return o1[1] - o2[1];
return o2[0] - o1[0];
}
});
LinkedList<int[]> queue = new LinkedList<>();
for (int[] person : people) {
queue.add(person[1], person);
}
return queue.toArray(new int[people.length][]);
}
}
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 射爆另外两个气球
既然按照起始位置排序,那么就从前向后遍历气球数组,靠左尽可能让气球重复。
从前向后遍历遇到重叠的气球了怎么办?
如果气球重叠了,重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。
package com.yzu.lee.greedy;
import java.util.Arrays;
import java.util.Comparator;
/**
* @ClassName: FindMinArrowShots
* @Description:在二维空间中有许多球形的气球。对于每个气球,提供的输入是水平方向上,气球直径的开始和结束坐标。 由于它是水平的,所以纵坐标并不重要,因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。
* 一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭,若有一个气球的直径的开始和结束坐标为 xstart,xend,
* 且满足 xstart ≤ x ≤ xend,则该气球会被引爆。可以射出的弓箭的数量没有限制。
* 弓箭一旦被射出之后,可以无限地前进。我们想找到使得所有气球全部被引爆,所需的弓箭的最小数量。
* 给你一个数组 points ,其中 points [i] = [xstart,xend] ,返回引爆所有气球所必须射出的最小弓箭数。
* @author: Leekuangyew
* @date: 2022/6/14 15:58
*/
public class FindMinArrowShots {
public int findMinArrowShots(int[][] points) {
Arrays.sort(points, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return o1[0] - o2[0];
}
});
int count = 1;
for (int i = 1; i < points.length; i++) {
if (points[i][0] - points[i - 1][1] > 0) count++;
else points[i][1] = Math.min(points[i - 1][1], points[i][1]);
}
return count;
}
}
435. 无重叠区间
给定一个区间的集合,找到需要移除区间的最小数量,使剩余区间互不重叠。
注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] 和 [2,3] 的边界相互“接触”,但没有相互重叠。
示例 1:
- 输入: [ [1,2], [2,3], [3,4], [1,3] ]
- 输出: 1
- 解释: 移除 [1,3] 后,剩下的区间没有重叠。
和452. 用最少数量的箭引爆气球方法一样,重点在于删除要删除右边界大的值 pre = Math.min(pre, intervals[i][1]);
package com.yzu.lee.greedy;
import java.util.Arrays;
import java.util.Comparator;
/**
* @ClassName: EraseOverlapIntervals
* @Description:给定一个区间的集合,找到需要移除区间的最小数量,使剩余区间互不重叠。 注意: 可以认为区间的终点总是大于它的起点。 区间 [1,2] 和 [2,3] 的边界相互“接触”,但没有相互重叠。
* @author: Leekuangyew
* @date: 2022/6/14 16:24
*/
public class EraseOverlapIntervals {
public int eraseOverlapIntervals(int[][] intervals) {
//按左边界排序
Arrays.sort(intervals, (int[] o1, int[] o2) -> {
return o1[0] - o2[0];
});
//
int count = 0;
int pre = Integer.MIN_VALUE;
for (int i = 0; i < intervals.length; i++) {
if (pre > intervals[i][0]) {
count++;
pre = Math.min(pre, intervals[i][1]);
} else pre = intervals[i][1];
}
return count;
}
}
763.划分字母区间
字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段,同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。
示例:
- 输入:S = “ababcbacadefegdehijhklij”
- 输出:[9,7,8] 解释: 划分结果为 “ababcbaca”, “defegde”, “hijhklij”。 每个字母最多出现在一个片段中。 像 “ababcbacadefegde”, “hijhklij” 的划分是错误的,因为划分的片段数较少。
提示:
- S的长度在[1, 500]之间。
- S只包含小写字母 ‘a’ 到 ‘z’ 。
利用hash找到每一个字母的最远遍历,再遍历当最远边界等于当前位置时,添加到结果集中
package com.yzu.lee.greedy;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName: PartitionLabels
* @Description:字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段,同一字母最多出现在一个片段中。
* 返回一个表示每个字符串片段的长度的列表。
* 示例:
* 输入:S = "ababcbacadefegdehijhklij"
* 输出:[9,7,8] 解释: 划分结果为 "ababcbaca", "defegde", "hijhklij"。
* 每个字母最多出现在一个片段中。 像 "ababcbacadefegde", "hijhklij" 的划分是错误的,因为划分的片段数较少。
* @author: Leekuangyew
* @date: 2022/6/14 16:46
*/
public class PartitionLabels {
public List<Integer> partitionLabels(String s) {
ArrayList<Integer> result = new ArrayList<>();
char[] chars = s.toCharArray();
int[] ints = new int[26];
for (int i = 0; i < chars.length; i++) {
ints[chars[i] - 'a'] = i;
}
//当前字符串的最远边界
int idx = 0;
int last = -1;
for (int i = 0; i < chars.length; i++) {
idx = Math.max(idx, ints[chars[i] - 'a']);
if (idx == i) {
result.add(i - last);
last = i;
}
}
return result;
}
}
56. 合并区间
给出一个区间的集合,请合并所有重叠的区间。
示例 1:
- 输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
- 输出: [[1,6],[8,10],[15,18]]
- 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
package com.yzu.lee.greedy;
import java.util.ArrayList;
import java.util.Arrays;
/**
* @ClassName: Merge
* @Description:给出一个区间的集合,请合并所有重叠的区间。 示例 1:
* 输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
* 输出: [[1,6],[8,10],[15,18]]
* 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
* @author: Leekuangyew
* @date: 2022/6/14 19:35
*/
public class Merge {
public int[][] merge(int[][] intervals) {
Arrays.sort(intervals, (a, b) -> {
return a[0] - b[0];
});
ArrayList<int[]> result = new ArrayList<>();
int start = intervals[0][0];
for (int i = 1; i < intervals.length; i++) {
if (intervals[i][0] > intervals[i - 1][1]) {
result.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]);
}
}
result.add(new int[]{start, intervals[intervals.length - 1][1]});
return result.toArray(new int[0][0]);
}
}
738.单调递增的数字
给定一个非负整数 N,找出小于或等于 N 的最大的整数,同时这个整数需要满足其各个位数上的数字是单调递增。
(当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时,我们称这个整数是单调递增的。)
示例 1:
- 输入: N = 10
- 输出: 9
局部最优:遇到strNum[i - 1] > strNum[i]的情况,让strNum[i - 1]–,然后strNum[i]给为9,可以保证这两位变成最大单调递增整数。
全局最优:得到小于等于N的最大单调递增的整数。
但这里局部最优推出全局最优,还需要其他条件,即遍历顺序,和标记从哪一位开始统一改成9。
package com.yzu.lee.greedy;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collections;
/**
* @ClassName: MonotoneIncreasingDigits
* @Description:当且仅当每个相邻位数上的数字x和y满足x <= y时,我们称这个整数是单调递增的。
* 给定一个整数 n ,返回 小于或等于 n 的最大数字,且数字呈 单调递增 。
* @author: Leekuangyew
* @date: 2022/6/15 16:13
*/
public class MonotoneIncreasingDigits {
public int monotoneIncreasingDigits(int n) {
String s = String.valueOf(n);
char[] chars = s.toCharArray();
int start = s.length();
//从后往前遍历数组,当当前数大于后一位数,当前数减一,并且start等于i+1;
for (int i = chars.length - 2; i >= 0; i--) {
if (chars[i] > chars[i + 1]) {
chars[i] -= 1;
start = i + 1;
}
}
for (int i = start; i < chars.length; i++) {
chars[i] = '9';
}
return Integer.parseInt(String.valueOf(chars));
}
@Test
public void test() {
monotoneIncreasingDigits(10);
}
}
968.监控二叉树
给定一个二叉树,我们在树的节点上安装摄像头。
节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
计算监控树的所有节点所需的最小摄像头数量。
示例 1:
- 输入:[0,0,null,0,0]
- 输出:1
- 解释:如图所示,一台摄像头足以监控所有节点。
重点:遍历顺序为后序,每个节点被划分为三个状态:有覆盖,无覆盖,有摄像头
package com.yzu.lee.greedy;
/**
* @ClassName: MinCameraCover
* @Description:给定一个二叉树,我们在树的节点上安装摄像头。 节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
* 计算监控树的所有节点所需的最小摄像头数量。
* @author: Leekuangyew
* @date: 2022/6/16 15:21
*/
public class MinCameraCover {
private int result;
public int minCameraCover(TreeNode root) {
result = 0;
if (traversal(root) == 0) {
result++;
}
return result;
}
private int traversal(TreeNode root) {
/**
* 节点0:表示无覆盖
* 节点1:表示有摄像头
* 节点2:表示有覆盖
*/
//空节点表示有覆盖
if (root == null) return 2;
//左右中 后序遍历
int left = traversal(root.left);
int right = traversal(root.right);
/**
* (1)当左节点和右节点都有覆盖,就直接返回0,表示当前节点无覆盖
* (2,2)
*/
if (left == 2 && right == 2) return 0;
/**
* (1)左右节点只要有一个为0,即为无覆盖,那么就返回2,当前节点有摄像头
* (0,1)(1,0)(0,0)(0,2)(2,0)
*/
else if (left == 0 || right == 0) {
result++;
return 1;
}
/**
*(1)左右节点有一个为1,即为有覆盖
* (1,2)(2,1)(1,1)
*/
else return 2;
}
}