leetcode刷题笔记——贪心算法

leetcode刷题笔记——贪心算法

目前完成的贪心相关的leetcode算法题序号：
中等：763

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reconstruct-itinerary
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

算法理解

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

---

提示：以下是贪心算法相关的刷题笔记

一、763题：划分字母区间

1.题干

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

2.思路

本次的解题思路包括五个步骤：
1）计算字符串中每个字符最后一次出现的索引；
2）要使得“同一个字母只出现在一个片段中”，就需要在某个片段中，所有的字符最后出现的索引值小于片段的最右端；
3）要使得尽可能多的划分片段，就要在字符串每次出现步骤2中情况的时候就进行划分；

3.代码

class Solution:
    def partitionLabels(self, S: str) -> List[int]:
        last_index = [0] * 26
		#查询每个字符在字符串中最后出现的位置的索引值
        for i, ch in enumerate(S):
            last_index[ord(ch) - ord("a")] = i
        ####这种需要计算区间长度的问题，用双指针会比较方便，省去了计数值不断赋值和恢复的问题！！！
        left, right = 0, 0
        counts = 0
        res = []
        for i, ch in enumerate(S):
        #右指针每次都更新为S当前位置下，前面所有字符最终出现位置的最大值
            right = max(right, last_index[ord(ch) - ord("a")])
            #将右指针与当前索引值进行比较，判断是否进行字符串划分
            if right == i:
            #通过左右指针计算区间长度，并更新左指针
                res.append(right-left+1)
                left = right + 1
        return res

注意：这种需要计算区间长度的问题，用双指针会比较方便，省去了计数值不断赋值和恢复的问题！！！

二、452题：用最少数量的箭引爆气球

1.题干

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

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

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

2.解题思路

1）将区间列表按照左边界升序排序；
2）构建新区间与前面的区间是否重合的判断区间；
2）遍历区间列表，比较每个区间的左边界，是否在判断区间范围内：

• 如果不在，则需要加一根箭，且判断区间重新设置为这个区间的左右边界；
• 如果在，则不需要加新的箭，将判断区间的右指针更新为其本身与新区间有边界的较小值；

3.代码

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        counts = 1
        #对区间列表按照区间的左边界进行排序
        points.sort()
        if len(points) == 0:
            return 0
        right = points[0][1]
		#初始右边界设置为第一个区间的右边界
        for point in points[1:]:
        #如果新区间的左边界不在“判断区间”中，则加一根箭，并将“判断区间”的右边界设置为新区间的右边界
            if point[0] > right:
                counts += 1
                right = point[1]
            else:
        #如果新区间的左边界在“判断区间”中，则不用加箭，并比较“判断区间”的右边界和新区间的右边界，取较小值作为新的“判断区间”的右边界
                right = min(right, point[1])
        return counts

三、406题：根据身高重建队列

1. 题干

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

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

2. 思路

以贪心思想为核心，根据条件对列表进行预排序，能够大大简化后续插入操作的时间复杂度。
1）ki表示这个队列中这个人前面高于等于他的人数，那么按照身高顺序排序后，，每个人的位置即应该为这个人的ki属性的值；
2）为了进一步减少后续插入操作的次数，还可以将同样身高的人中，ki值较大的排在后面，为了不影响最终的按照身高排序的原则，可以先对每个人按照ki值进行升序排列，然后在对身高值进行降序排列；
3）完成排序之后，每个人所在的位置索引应该等于ki值，这就需要进行插入操作，由于身高矮的人所在的位置对身高高的人没有影响，所以先确定身高高的人的位置，即对排序后的列表，从左到右遍历，进行相应的插入操作；

3. 代码

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
        people.sort(key=lambda x:x[1])
        #注意：sort（）函数如果不指定key，会依次对h，k进行排序，这里需要指定排序的key
        people.sort(key=lambda x:x[0], reverse=True)
        # 排序之后，从左到右遍历，对列表中的人按照ki属性值，插入到对应的索引位置
        for i in range(len(people)):
            mark = people[i][1]
            k = i
            tmp = people[i]
            while mark < k:
                people[k] = people[k-1]
                k -= 1
            people[mark] = tmp
        return people

四、665题：非递减数列

1. 题干

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

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

2. 解题思路

贪心算法：
1）首先遍历一次数组，查找数组中第一次出现的递减的位置，对出现递减情况的数值进行修正，具体的修正方法为：

• 如果是在数组最后一个位置才出现的递减情况，则修改最后一个元素值，必然能够满足要求，返回True;
• 如果不是最后一个位置出现，则需要判断出现递减情况的原因是后一个元素 i+1 小了，还是前一个元素 i 大了，这可以通过比较 i 元素与 i + 2 的大小来判断：
• 如果元素 i 大于 i+2 ，则说明元素 i 大了，这时就要用到贪心的思想，将元素 i 的值修正为元素 i+1 的值（将 i 缩小，使得缩小的程度最低，尽可能不影响 i 与 i-1的大小关系，如果这样都还会影响与 i-1 的大小关系，则说明该数组不能满足要求）
• 如果元素 i 小于 i+2，则说明元素 i+1 小了，需要将元素 i+1 增大为元素 i 的大小，同样使用了贪心的思想

2）如果该数组能够满足题目的要求，则经过1）的修正后，一定是不会再出现递减的情况了，所以这里再次遍历数组，如果再次出现递减的情况，则返回False，如果没有再出现，则返回True

注意：核心就是如何修正第一次出现递减情况处的元素值，一定要把握住：要么是递减处的第一个元素大了，要么是第二个元素小了，具体是那种情况要根据第一个元素与之后的元素进行大小比较确定，而具体的修正值，要根据贪心思想，修正后的结果应等效于删除异常值的效果。

3. 代码

class Solution:
    def checkPossibility(self, nums: List[int]) -> bool:
        counts = 0
        #第一次遍历数组，查找第一次出现递减情况的元素
        for i in range(len(nums)-1):
            if nums[i] > nums[i+1]:
            #如果是在数组的末尾出现，则修正末尾元素之后，必然满足要求
                if i == len(nums)-2:
                    return True
            #如果不是末尾处，如果是元素i太大了，将其减小为i+1元素值
                elif nums[i] > nums[i+2]:
                    nums[i] = nums[i+1]
            #否则就是元素i+1太小了，将其增大为元素i的值
                else:
                    nums[i+1] = nums[i]
            #修正第一个递减情况的问题元素之后，结算修正的循环
                break
        #开始第二轮检索循环，如果没有再出现递减的情况，则满足要求，否则不满足
        for i in range(len(nums)-1):
            if nums[i] > nums[i+1]:
                return False
        return True