LeetCode题解：贪心算法专栏

LeetCode题解：贪心算法

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

---

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

参考资料： 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。

题解：

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

算法实现： Java

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);

        int child=0,cookie=0;
        while (child<g.length && cookie<s.length){
            if (g[child]<=s[cookie])
                child++;
            cookie++;
        }

        return child;
    }
}

135. 分发糖果

难度： 困难

老师想给孩子们分发糖果，有 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;
    }

}

435. 无重叠区间

难度： 中等

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

注意:

1. 可以认为区间的终点总是大于它的起点。
2. 区间 [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<int[]>() {
            @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] <prev) {
                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<int[]>() {
            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;
    }
}

605. 种花问题

难度： 简单

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

给你一个整数数组 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;
    }
}

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

难度： 中等

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

一支弓箭可以沿着 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<int[]>() {
            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<points.length;i++){
            if(points[i][0] <= pre){

            }else{
                pre = points[i][1];
                total++;
            }
        }
        return total;
    }
}

763. 划分字母区间

难度： 中等

字符串 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<Integer> 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<Integer> 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;
    }

}

122. 买卖股票的最佳时机 II

难度简单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;

    }
}

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]] 是重新构造后的队列。

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

解题思路：

先排序再插入

• 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<int[]> 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;
    }
}

665. 非递减数列

难度简单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]<nums[i-1]){
                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月

---