c语言贪心算法合并箭,LeetCode刷题题库：贪心算法

LeetCode刷题笔记：贪心算法

自大学开始，我便陆陆续续的学习一些 算法和数据结构 方面的内容，同时也开始在一些平台刷题，也会参加一些大大小小的算法竞赛。但是平时刷题缺少目的性、系统性，最终导致算法方面进步缓慢。最终，为了自己的未来，我决定开始在LeetCode上进行系统的学习和练习，同时将刷题的轨迹整理记录，分享出来与大家共勉。

参考教材： LeetCode 101 - A LeetCode Grinding Guide

参考资料： LeetCode社区官方提供的思路/题解 以及 评论区/题解区各路大神提供的思路/答案

目录标题

LeetCode刷题笔记：贪心算法

[455. 分发饼干](https://leetcode-cn.com/problems/assign-cookies/)

[135. 分发糖果](https://leetcode-cn.com/problems/candy/)

[435. 无重叠区间](https://leetcode-cn.com/problems/non-overlapping-intervals/)

[605. 种花问题](https://leetcode-cn.com/problems/can-place-flowers/)

[452. 用最少数量的箭引爆气球](https://leetcode-cn.com/problems/minimum-number-of-arrows-to-burst-balloons/)

[763. 划分字母区间](https://leetcode-cn.com/problems/partition-labels/)

[122. 买卖股票的最佳时机 II](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/)

[406. 根据身高重建队列](https://leetcode-cn.com/problems/queue-reconstruction-by-height/)

[665. 非递减数列](https://leetcode-cn.com/problems/non-decreasing-array/)

算法解释：

顾名思义，贪心算法或贪心思想采用贪心的策略，保证每次操作都是局部最优的，从而使最后得到的结果是全局最优的。

举一个最简单的例子：小明和小王喜欢吃苹果，小明可以吃五个，小王可以吃三个。已知苹 果园里有吃不完的苹果，求小明和小王一共最多吃多少个苹果。在这个例子中，我们可以选用的 贪心策略为，每个人吃自己能吃的最多数量的苹果，这在每个人身上都是局部最优的。又因为全 局结果是局部结果的简单求和，且局部结果互不相干，因此局部最优的策略也同样是全局最优的 策略。

难度： 简单

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

对每个孩子 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。

题解：

因为饥饿度最小的孩子最容易吃饱，所以我们先考虑这个孩子。为了尽量使得剩下的饼干可以满足饥饿度更大的孩子，所以我们应该把大于等于这个孩子饥饿度的、且大小最小的饼干给这个孩子。满足了这个孩子之后，我们采取同样的策略，考虑剩下孩子里饥饿度最小的孩子，直到没有满足条件的饼干存在。

算法实现： Java

class Solution {

public int findContentChildren(int[] g, int[] s) {

Arrays.sort(g);

Arrays.sort(s);

int child=0,cookie=0;

while (child

if (g[child]<=s[cookie])

child++;

cookie++;

}

return child;

}

}

难度： 困难

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。

评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果。

那么这样下来，老师至少需要准备多少颗糖果呢？

示例：

输入：[1,0,2]

输出：5

解释：你可以分别给这三个孩子分发 2、1、2 颗糖果。

题解：

只需要简单的两次遍历即可：

把所有孩子的糖果数初始化为 1； 先从左往右遍历一遍，如果右边孩子的评分比左边的高，则右边孩子的糖果数更新为左边孩子的 糖果数加 1；再从右往左遍历一遍，如果左边孩子的评分比右边的高，且左边孩子当前的糖果数 不大于右边孩子的糖果数，则左边孩子的糖果数更新为右边孩子的糖果数加 1。通过这两次遍历， 分配的糖果就可以满足题目要求了。

这里的贪心策略即为，在每次遍历中，只考虑并更新相邻一 侧的大小关系。

算法实现： Java

class Solution {

public int candy(int[] ratings) {

int[] tang=new int[ratings.length];

for (int i = 0; i < tang.length; i++) {

tang[i]=1;

}

//从左往右

for (int i = 1; i < tang.length; i++) {

if (ratings[i]>ratings[i-1]){

tang[i]=tang[i-1]+1;

}

}

//从右往左

for (int i=tang.length-2;i>=0;i--){

if (ratings[i]>ratings[i+1]){

tang[i]=Math.max(tang[i],tang[i+1]+1);

}

}

//求和

int sum=0;

for (int i = 0; i < tang.length; i++) {

sum+=tang[i];

}

return sum;

}

}

难度： 中等

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。

区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

示例:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。

题解：

在选择要保留区间时，区间的结尾十分重要：选择的区间结尾越小，余留给其它区间的空间就越大，就越能保留更多的区间。因此，我们采取的贪心策略为，优先保留结尾小且不相交的区间。

具体实现方法为，先把区间按照结尾的大小进行增序排序，每次选择结尾最小且和前一个选择的区间不重叠的区间。

在样例中，排序后的数组为 [[1,2], [1,3], [2,4]]。按照我们的贪心策略，首先初始化为区间[1,2]；由于 [1,3] 与 [1,2] 相交，我们跳过该区间；由于 [2,4] 与 [1,2] 不相交，我们将其保留。因此最终保留的区间为 [[1,2], [2,4]]。

算法实现： Java

class Solution {

public int eraseOverlapIntervals(int[][] intervals) {

if ((intervals == null || intervals.length == 0)

|| (intervals.length == 1 && intervals[0].length == 0)) {

return 0;

}

Arrays.sort(intervals, new Comparator() {

@Override

public int compare(int[] o1, int[] o2) {

return o1[1] - o2[1];

}

});

// System.out.println(Arrays.deepToString(intervals));

int n = intervals.length;

int total = 0;

int prev = intervals[0][1];

for (int i = 1; i < n; i++) {

if (intervals[i][0]

total++;

}else {

prev = intervals[i][1];

}

}

return n - total;

}

}

算法实现： Java

class Solution2 {

public int eraseOverlapIntervals(int[][] intervals) {

if (intervals.length == 0) {

return 0;

}

Arrays.sort(intervals, new Comparator() {

public int compare(int[] interval1, int[] interval2) {

return interval1[1] - interval2[1];

}

});

int n = intervals.length;

int right = intervals[0][1];

int ans = 1;

for (int i = 1; i < n; ++i) {

if (intervals[i][0] >= right) {

++ans;

right = intervals[i][1];

}

}

return n - ans;

}

}

难度： 简单

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false。

示例：

输入：flowerbed = [1,0,0,0,1], n = 1

输出：true

题解：

判断能否在不打破种植规则的情况下在花坛内种入 nn 朵花，从贪心的角度考虑，应该在不打破种植规则的情况下种入尽可能多的花，然后判断可以种入的花的最多数量是否大于或等于 nn。

防御式编程思想：在 flowerbed 数组两端各增加一个 0， 这样处理的好处在于不用考虑边界条件，任意位置处只要连续出现三个 0 就可以栽上一棵花。

算法实现： Java

class Solution {

public boolean canPlaceFlowers(int[] flowerbed, int n) {

//防御式编程思维

int temp[]=new int[flowerbed.length+2];

temp[0]=0;

temp[temp.length-1]=0;

for (int i = 1; i < temp.length-1; i++) {

temp[i]=flowerbed[i-1];

}

// System.out.println(Arrays.toString(temp));

// System.out.println(Arrays.toString(flowerbed));

int ans=0;

//开始种花

for (int i = 1; i < temp.length-1; i++) {

if (temp[i] == 0 && temp[i - 1] == 0 && temp[i + 1] == 0) {

temp[i] = 1;

ans++;

}

}

return ans>=n;

}

}

难度： 中等

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

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

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

示例：

输入：points = [[10,16],[2,8],[1,6],[7,12]]

输出：2

解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

解题思路1：

和其他合并区间类的题目套路一样, 都是贪心思想, 先排序, 然后遍历检查是否满足合并区间的条件，这里判断是否有交叉区间, 所以其实是计算已知区间的交集数量。这里以[[10,16],[2,8],[1,6],[7,12]] 为例子:

先排序, 我是按区间开始位置排序, 排序后: [[1,6],[2,8],[7,12],[10,16]]

遍历计算交叉区间(待发射箭头),

待发射箭头的区间range = [1, 6], 需要的箭数量 arrows = 1;

区间[2, 8], 和带发射区间[1, 6]有交集: 更新发射区域为它们的交集 range = [2, 6]

区间[7, 12], 和待发射区间[2, 6]没有任何交集, 说明需要增加一个新的发射区域, 新的待发射区域range = [7, 12]

区间[10,16], 和待发射区域[7, 12]有交集, 待发射区域更新为[10, 12]

返回需要待发射区间的个数

算法实现： Java

class Solution {

public int findMinArrowShots(int[][] points) {

if (points.length <= 1) {

return points.length;

}

Arrays.sort(points, (p1, p2) -> p1[0] != p2[0] ? Integer.compare(p1[0], p2[0]) : Integer.compare(p1[1], p2[1]));

// System.out.println(Arrays.deepToString(points));

//初始化待发射区间

int holdStart = points[0][0]; // 当前维持的交集起点

int holdEnd = points[0][1]; // 当前维持的交集终点

int counts = 0; // 当前收集到的交集数量

for (int i = 1; i < points.length; i++) {

int[] point=points[i];//当前点

int curStart=point[0];

int curEnd=point[1];

if (curStart>holdEnd){

//当前没有交集

counts++;//增加发射区域

//新的等待发射区域

holdStart=curStart;

holdEnd=curEnd;

}else {

//当前有交集，更新发射区域为他们的交集

holdStart=Math.max(holdStart,curStart);

holdEnd=Math.min(holdEnd,curEnd);

}

}

counts++;

return counts;

}

}

解题思路2：

用区间的尾部排序貌似效率会更好, 因为已经保证后面的区间右侧都是大于当前区间, 所以将发射点设置在右侧边界, 后面的区间只有左边界比它更靠左,则可以被一起处理掉

这里换个example: [[10,16],[2,5],[1,6],[7,12]] 为例子:

先排序, 按区间结束位置排序, 排序后: [[2,5],[1, 6],[7,12],[10,16]]

遍历计算交叉区间,

发射点初始化为pos = 5, 需要的箭数量 arrows = 1;

区间[1, 6], 1 是小于5的, 在点5射箭可以干掉这个区间

区间[7, 12], 在5的位置射箭无法打掉, 说明需要增加一个新的发射点, 新的待发射点pos = 12

区间[10,16], 10 < 12那么在12位置射箭可以干掉它

返回需要射击点数量

算法实现： Java

class Solution3 {

public int findMinArrowShots(int[][] points) {

if(points.length < 2){

return points.length;

}

Arrays.sort(points, new Comparator() {

public int compare(int[] point1, int[] point2) {

if (point1[1] > point2[1]) {

return 1;

} else if (point1[1] < point2[1]) {

return -1;

} else {

return 0;

}

}

});

// System.out.println(Arrays.deepToString(points));

int total = 1;

int pre = points[0][1];

for(int i = 1;i

if(points[i][0] <= pre){

}else{

pre = points[i][1];

total++;

}

}

return total;

}

}

难度： 中等

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。

示例：

输入：S = "ababcbacadefegdehijhklij"

输出：[9,7,8]

解释：

划分结果为 "ababcbaca", "defegde", "hijhklij"。

每个字母最多出现在一个片段中。

像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。

题解：

其实思路很简单，

1， 首先看第一个字母，找到它在串里最后的一个位置，记作last或一段的最后位置。

2， 在从0~last这个范围里，挨个查其他字母，看他们的最后位置是不是比刚才的last或一段的最后位置大。

如果没有刚才的last或一段的最后位置大，无视它继续往后找。

如果比刚才的大，说明这一段的分隔位置必须往后移动，所以我们把last或一段的最后位置更新为当前的字母的最后位置。

3，肯定到有一个时间，这个last就更新不了了，那么这个时候这个位置就是我们的分隔位置。

注意题目要分隔后的长度，我们就用last - startindex + 1。

4，找到一个分割位，更新一下起始位置，同理搜索就行了。

算法实现： Java

class Solution {

public List partitionLabels(String s) {

int[] map = new int[26];//记录每个字母对应的最远位置。

Arrays.fill(map, -1);

for (int i = 0; i < s.length(); i++) {

map[s.charAt(i) - 'a'] = i;

}

int start = 0;//做切割的开始位置。

int scannedCharMaxPos = 0;//已扫描的字符能去到的最远位置。

List res = new ArrayList<>();

for (int i = 0; i < s.length(); i++) {

int currentCharMaxPos = map[s.charAt(i) - 'a'];

scannedCharMaxPos = Math.max(scannedCharMaxPos, currentCharMaxPos);

if (i == scannedCharMaxPos) {

res.add(i - start + 1);

start = i + 1;

}

}

return res;

}

}

难度简单1093收藏分享切换为英文接收动态反馈

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。

**注意：**你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例:

输入: [7,1,5,3,6,4]

输出: 7

解释: 在第 2 天(股票价格 = 1)的时候买入，在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。

随后，在第 4 天(股票价格 = 3)的时候买入，在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

题解：

股票买卖策略：

单独交易日： 设今天价格 p1 、明天价格 p2 ，则今天买入、明天卖出可赚取金额 p2 - p1(负值代表亏损)。

连续上涨交易日： 设此上涨交易日股票价格分别为 p1, p2, … , pn ，则第一天买最后一天卖收益最大，即 pn - p1 ；等价于每天都买卖，即 pn - p1=(p2 - p1)+(p3 - p2)+…+(pn - p{n-1})

连续下降交易日： 则不买卖收益最大，即不会亏钱。

算法流程：

遍历整个股票交易日价格列表 price，策略是所有上涨交易日都买卖(赚到所有利润)，所有下降交易日都不买卖(永不亏钱)。

设 tmp 为第 i-1 日买入与第 i 日卖出赚取的利润，即 tmp = prices[i] - prices[i - 1] ；

当该天利润为正 tmp > 0，则将利润加入总利润 profit；当利润为 00 或为负，则直接跳过；

遍历完成后，返回总利润 profit。

算法实现： Java

class Solution {

public int maxProfit(int[] prices) {

int profit=0;

for (int i = 1; i < prices.length; i++) {

int tmp=prices[i]-prices[i-1];

if (tmp>0){

profit+=tmp;

}

}

return profit;

}

}

难度：中等

假设有打乱顺序的一群人站成一个队列，数组 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]] 是重新构造后的队列。

套路：一般这种数对，还涉及排序的，根据第一个元素正向排序，根据第二个元素反向排序，或者根据第一个元素反向排序，根据第二个元素正向排序，往往能够简化解题过程。

解题思路：

先排序再插入

1.排序规则：按照先H高度降序，K个数升序排序

2.遍历排序后的数组，根据K插入到K的位置上

核心思想：高个子先站好位，矮个子插入到K位置上，前面肯定有K个高个子，矮个子再插到前面也满足K的要求

示例解题过程模拟

排序后

[7,0], [7,1], [6,1], [5,0], [5,2], [4,4]

再一个一个插入。

[7,0]//在位置0插入7

[7,0], [7,1]//在位置1插入7

[7,0], [6,1], [7,1]//在位置1插入6

[5,0], [7,0], [6,1], [7,1]//在位置0插入5

[5,0], [7,0], [5,2], [6,1], [7,1]//在位置2插入5

[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]//在位置4插入4

算法实现： Java

class Solution {

public int[][] reconstructQueue(int[][] people) {

Arrays.sort(people,(o1, o2) -> o1[0]==o2[0]?o1[1]-o2[1]:o2[0]-o1[0]);

// System.out.println(Arrays.deepToString(people));

LinkedList linkedList=new LinkedList<>();

for (int i = 0; i < people.length; i++) {

linkedList.add(people[i][1],people[i]);

}

int[][] arrayList=linkedList.toArray(new int[linkedList.size()][2]);

// System.out.println(Arrays.deepToString(arrayList));

return arrayList;

}

}

难度简单531收藏分享切换为英文接收动态反馈

给你一个长度为 n 的整数数组，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。

我们是这样定义一个非递减数列的： 对于数组中任意的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。

示例:

输入: nums = [4,2,3]

输出: true

解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。

题解：

参考：https://leetcode-cn.com/problems/non-decreasing-array/solution/3-zhang-dong-tu-bang-zhu-ni-li-jie-zhe-d-06gi/

首先，看下面的几个测试用例，它们都因为数字 2 的出现，导致数组是非单调递增的。

例①： 4, 2, 5

例②： 1, 4, 2, 5

例③： 3, 4, 2, 5

当数组中出现 2 时，破坏了数组的单调递增。为了让数组有序，我们需要对 2 或者 4 进行调整：

第①个用例，我们可以 把 4 调小到 <= 2 或者 把 2 调大到 4、5 ，使数组有序。

第②个用例，我们可以 把 4 调小到 1、2 或者 把 2 调大到 4、5 ，使数组有序。

第③个用例，我们必须 把 2 调大到 4、5，才能使数组有序：我们不能把 4 调整为一个 <= 2 的数字，因为 4 前面的元素是 3.

归纳总结

当 nums[i] 破坏了数组的单调递增时，即 nums[i] < nums[i - 1] 时，为了让数组有序，我们发现一个规律(在上面三个例子中， nums[i] 都为 2， nums[i -1] 都为 4)：

如例①的情况，当 i = 1 ，那么修改 num[i- 1] ，不要动 nums[i] ，因为nums[i]后面的元素是啥我们还不知道呢，少动它为妙。

如例②的情况，当 i > 1 时，我们应该优先考虑把 nums[i - 1] 调小到 >= nums[i - 2] 并且 <= nums[i]。同样尽量不去修改 nums[i] ，理由同上。

如例③的情况，当 i > 1 且 nums[i] < nums[i - 2] 时，我们无法调整 nums[i - 1] ，我们只能调整 nums[i] 到 nums[i - 1] 。

算法实现： Java

class Solution {

public boolean checkPossibility(int[] nums) {

int count=0;

for (int i = 1; i < nums.length; i++) {

if (nums[i]

if (i==1 || nums[i]>=nums[i-2]){

nums[i-1]=nums[i];

}else{

nums[i]=nums[i-1];

}

if (++count>1){

return false;

}

}

}

return true;

}

}

作者：耿鬼不会笑

时间：2021年2月