860. 柠檬水找零
思路：
只需要维护三种金额的数量，5，10和20。
有如下三种情况：
- 情况一：账单是5，直接收下。
- 情况二：账单是10，消耗一个5，增加一个10
- 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5
此时大家就发现 情况一，情况二，都是固定策略，都不用我们来做分析了，而唯一不确定的其实在情况三。
而情况三逻辑也不复杂甚至感觉纯模拟就可以了，其实情况三这里是有贪心的。
账单是20的情况，为什么要优先消耗一个10和一个5呢？
因为美元10只能给账单20找零，而美元5可以给账单10和账单20找零，美元5更万能！
所以局部最优：遇到账单20，优先消耗美元10，完成本次找零。全局最优：完成全部账单的找零。
代码：
class Solution:
def lemonadeChange(self, bills: List[int]) -> bool:
five = 0
ten = 0
twenty = 0
for bill in bills:
# 情况一：收到5美元
if bill == 5:
five += 1
# 情况二：收到10美元
if bill == 10:
if five <= 0:
return False
ten += 1
five -= 1
# 情况三：收到20美元
if bill == 20:
# 先尝试使用10美元和5美元找零
if five > 0 and ten > 0:
five -= 1
ten -= 1
#twenty += 1
# 如果无法使用10美元找零，则尝试使用三张5美元找零
elif five >= 3:
five -= 3
#twenty += 1
else:
return False
return True- 时间复杂度: O(n)
- 空间复杂度: O(1)
406. 根据身高重建队列
思路：
本题有两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后再按照另一个维度重新排列。
如果两个维度一起考虑一定会顾此失彼。
对于本题相信大家困惑的点是先确定k还是先确定h呢，也就是究竟先按h排序呢，还是先按照k排序呢？
如果按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件，两个维度哪一个都没确定下来。
那么按照身高h来排序呢，身高一定是从大到小排（身高相同的话则k小的站前面），让高个子在前面。
此时我们可以确定一个维度了，就是身高，前面的节点一定都比本节点高！
那么只需要按照k为下标重新插入队列就可以了，为什么呢？
以图中{5,2} 为例：
按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。
所以在按照身高从大到小排序后：
局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性
全局最优：最后都做完插入操作，整个队列满足题目队列属性
局部最优可推出全局最优，找不出反例，那就试试贪心。
代码：
class Solution:
def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
# 先按照h维度的身高顺序从高到低排序。确定第一个维度
# lambda返回的是一个元组：当-x[0](维度h）相同时，再根据x[1]（维度k）从小到大排序
people.sort(key=lambda x: (-x[0], x[1]))
que = []
# 根据每个元素的第二个维度k，贪心算法，进行插入
# people已经排序过了：同一高度时k值小的排前面。
for p in people:
que.insert(p[1], p)
return que- 时间复杂度：O(nlog n + n^2)
- 排序时间复杂度：
people.sort(key=lambda x: (-x[0], x[1]))使用了Python内置的sort方法，其时间复杂度通常是O(n log n)，其中n是people列表的长度。这是因为排序算法通常基于比较操作，而比较排序算法的平均时间复杂度是O(n log n)。 - 插入时间复杂度：在排序后，对于每个元素
p，我们执行que.insert(p[1], p)。列表的insert方法在Python中的时间复杂度是O(k)，其中k是插入位置之后的元素数量。在最坏的情况下，每次插入都在列表的开头，此时k接近于列表的长度n。因此，总插入时间复杂度为O(n^2)，因为我们需要对n个元素执行插入操作，而每次插入在最坏情况下都是O(n)。综上所述，整个方法的时间复杂度主要由插入操作决定，因此总时间复杂度为O(n^2)。 - 空间复杂度：O(n)
-
额外空间：除了输入列表
people和输出列表que外，我们没有使用任何额外的数据结构来存储数据。排序操作是原地进行的，不需要额外空间（除了Python解释器可能用于排序的内部空间）。 -
输出列表：
que列表与people列表具有相同的长度n，因此它占用的空间是O(n)。
补充：
people.sort(key=lambda x: (-x[0], x[1])) 这段代码是Python中对一个名为people的列表进行排序的代码。
首先，我们逐步解析这段代码：
-
people: 这是一个列表，假设它包含多个元素，每个元素都是一个元组或列表。例如，
people可能是这样的：[(3, 'Alice'), (1, 'Bob'), (2, 'Charlie')] -
sort(): 这是Python列表的一个方法，用于对列表中的元素进行原地排序。这意味着排序会直接在原列表上进行，而不是返回一个新的排序后的列表。
-
key=lambda x: (-x[0], x[1]): 这是
sort()方法的一个参数，它决定了排序的规则。- lambda x: 这是一个匿名函数（也称为lambda函数），它接受一个参数
x。在这里，x是people列表中的一个元素。 - -x[0]: 对于列表中的每个元素（在这里是元组或列表），我们取它的第一个元素（索引为0）并取其相反数。这通常用于降序排序。
- x[1]: 对于列表中的每个元素，我们也取它的第二个元素（索引为1）。这将用于当第一个元素相同时的排序。
- lambda x: 这是一个匿名函数（也称为lambda函数），它接受一个参数
因此，整个排序规则是：首先根据第一个元素进行降序排序，如果第一个元素相同，则根据第二个元素进行升序排序。
452. 用最少数量的箭引爆气球
思路：
局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。
为了让气球尽可能的重叠，需要对数组进行排序。
那么按照气球起始位置排序，还是按照气球终止位置排序呢？
其实都可以！只不过对应的遍历顺序不同，我就按照气球的起始位置排序了。
既然按照起始位置排序，那么就从前向后遍历气球数组，靠左尽可能让气球重复。
以题目示例： [[10,16],[2,8],[1,6],[7,12]]为例，如图：（方便起见，已经排序）
可以看出首先第一组重叠气球，一定是需要一个箭，气球3，的左边界大于了 第一组重叠气球的最小右边界，所以再需要一支箭来射气球3了。
代码：
class Solution:
def findMinArrowShots(self, points: List[List[int]]) -> int:
if len(points) == 0:
return 0
points.sort(key=lambda x: x[0])
result = 1
for i in range(1, len(points)):
if points[i][0] > points[i - 1][1]: # 气球i和气球i-1不挨着，注意这里不是>=
result += 1
else:
points[i][1] = min(points[i - 1][1], points[i][1]) # 更新重叠气球最小右边界，取当前气球右边界和上个气球右边界的最小值
return result- 时间复杂度：O(nlog n)，因为有一个快排
- 空间复杂度：O(1)，有一个快排，最差情况(倒序)时，需要n次递归调用。因此确实需要O(n)的栈空间
![【Hadoop】-Hive部署[12]](https://img-blog.csdnimg.cn/direct/7b640b8b7b574589ba766555d2e31763.png)
