135. 分发糖果
n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
你需要按照以下要求，给这些孩子分发糖果：
-
每个孩子至少分配到
1个糖果。 -
相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
解题思路
题目的要求是相邻两个孩子中评分更高的孩子会获得更多的糖果，这也就是说我们需要双边比较，有点像前面的求峰值点数。但是这道题让我们统计的是糖果数，双边比较的话太容易出错了。我们可以用两次单边比较求出。
第一次遍历，从左向右，这时候判断右边孩子是否大于左边孩子，如果大于，则在左边孩子获得糖果数量的基础上加1；如果不大于，则赋值为1即可。这里的初始化为赋值列表全为1即可。
第二次遍历，从右向左，这时候就要判断左孩子是否大于右孩子，如果大于，则在第一次遍历右孩子糖果数量的基础上加1，并与第一次遍历得到的左孩子糖果数量比较，取较大的那一个，因为较大的数量能同时满足两次遍历的结果；如果不大于，不作修改即可。
代码如下：
class Solution:
def candy(self, ratings: List[int]) -> int:
candy_ = [1] * len(ratings)
for i in range(1,len(ratings)):
#从左向右遍历
if ratings[i] > ratings[i - 1]:
candy_[i] = candy_[i - 1] + 1
else :
candy_[i] = 1
print(candy_)
for i in range(2,len(ratings) + 1):
#从右向左遍历
if ratings[len(ratings) - i] > ratings[len(ratings) - i + 1]:
candy_[len(ratings) - i] = max(candy_[len(ratings) - i],candy_[len(ratings) - i + 1] + 1)
print(candy_)
return sum(candy_)860. 柠檬水找零
在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
注意，一开始你手头没有任何零钱。
给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
解题思路
注意，这道题不能按照自己有多少钱来算，因为这样算的话会把10美元拆开，这样就会出错。正确的算法应该是对手里的5美元和10美元分别计数，按照其数目多少判断是否能够找零。
分情况讨论。
1.如果客户给了5美元，那么5美元的数值加1.
2.如果客户给了10美元，那么5美元的数值减1，10美元的数值加1。
3.如果客户给了20美元，那么优先花出10美元，再花出5美元。
因此，这里的贪心就是花出去尽可能多的10美元，保留5美元，因为5美元在找零中是万能的。
在以上三种情况中还存在着不同的情境，在第二种情况下，如果5美元的数量不够，那么返回False；在第三种情况下，如果10美元或5美元的数量不够，那么返回False。代码如下：
class Solution:
def lemonadeChange(self, bills: List[int]) -> bool:
five = 0
ten = 0
for i in range(len(bills)):
if bills[i] == 5:
five += 1
elif bills[i] == 10:
ten += 1
if five >= 1:
five -= 1
else:
return False
elif bills[i] == 20:
if ten >= 1 and five >= 1:
ten -= 1
five -= 1
elif ten >= 1 and five <= 0:
return False
elif ten <= 0 and five >= 3:
five -= 3
elif ten <=0 and five < 3:
return False
return True406. 根据身高重建队列
假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。
请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。
解题思路
这道题有点像前面的糖果题，都是从二维的角度来出题的，遇到这种类型的题，我们直接单边考虑即可。
首先我们先试试按照次序k排个序，对于[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]],得到[[5, 0], [7, 0], [6, 1], [7, 1], [5, 2], [4, 4]]，这样看数组还是很乱，身高和次序都没有排好。
我们再来尝试下按身高排序，得到[[7, 0], [7, 1], [6, 1], [5, 0], [5, 2], [4, 4]]，这样的话就比较清楚些了，最起码排好了大体的身高次序，接下来只需要按照次序k插入元素即可。代码如下：
class Solution:
def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
people.sort(key = lambda x: (-x[0], x[1])) #按照身高从大到小，序号从小到大排
que = []
for p in people:
que.insert(p[1],p)
return que注意，这里insert()函数的用法是，第一项p[1]代表插入的位置，这里的p[1]即为people数组中的次序k，例如[5,0]元素，就是插入到了数组中的位置0.第二项p代表需要插入的元素。
452. 用最少数量的箭引爆气球
有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。
一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 x``start，x``end， 且满足 xstart ≤ x ≤ x``end，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。
给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。
解题思路
首先来画个图直观的看一下。这里的排序是为了能让最有可能重叠的球都尽量挨在一起，便于判断。
可以发现，当球的右边界大于等于下一个球的左边界时，这两个球可以被一支箭射爆，当球的右边界小于下一个球的左边界时，这个球只能单独被射爆。
再来看可以重叠射爆的情况，两个球可以重叠时，我们怎么判断下个球能不能被重叠进去呢？观察一下就可以知道，重叠的区域是有限的，我们需要更新重叠的右边界，如上图绿线。更新之后，将新边界作为上一个球的右边界，与现在的球的左边界比较即可判断。代码如下：
class Solution:
def findMinArrowShots(self, points: List[List[int]]) -> int:
points.sort(key = lambda x: (x[0], x[1]))
result = 0
for i in range(1, len(points)):
if points[i - 1][1] < points[i][0]:
result += 1
else :
points[i][1] = min(points[i - 1][1], points[i][1])
result += 1 #此处加一是因为循环中没法对最后一个球进行处理
return result435. 无重叠区间
给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。
解题思路
这道题和上道题差不多，可以按照上道题的思路进行重叠的计数，直接输出即可。代码如下：
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
result = 0 #用于标记重叠的个数
intervals.sort(key = lambda x:(x[0], x[1]))
for i in range(1, len(intervals)):
if intervals[i][0] >= intervals[i - 1][1]: #左边界大于右边界不重叠
continue
else: #重叠
result += 1
intervals[i][1] = min(intervals[i - 1][1],intervals[i][1])
return result
763. 划分字母区间
给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。
注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。
返回一个表示每个字符串片段的长度的列表。
解题思路
贪心算法的题一般看第一眼都没啥思路，所以这时候画个图，把所有必要信息列在图中可能就有思路了，如下：
这样思路就清晰多了，对于每个字符，我们统计出他的最远位置，然后与下标进行比较，如果下标与一段的最远位置相同了，就说明这是一段。代码如下：
class Solution:
def partitionLabels(self, s: str) -> List[int]:
dic = {} #哈希表统计每个字符出现的最远位置
for i in range(len(s)):
dic[s[i]] = i
ans = [] #存储答案
index_max = 0 #用于表示每一段的最大下标
len_max = 0 #用于表示每一段的最大长度
for i in range(len(s)):
index_max = max(dic.get(s[i], 0), index_max)
len_max += 1
if i == index_max:
ans.append(len_max)
len_max = 0
return ans56. 合并区间
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
解题思路
同样画图来看。
根据图来模拟一下过程，与前面判断重叠的方法类似，都是看下一个区间的左边界与上个区间的右边界的关系来判断，只不过这里如果判为了重叠区间，则不是在对区间的右边界取最小值了，而是取最大值，因为这并不需要多个区间都有相同的一段。只需要连接在一起即可。
因为end随重叠区间改变，所以在判断为不是重叠区间时才将不重叠区间加入到答案数组中。代码如下：
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
intervals.sort(key = lambda x:(x[0], x[1]))
ans = []
start = intervals[0][0] #区间数组左边界
end = intervals[0][1] #区间数组右边界
for i in range(1, len(intervals)):
#重叠
if intervals[i - 1][1] >= intervals[i][0]:
end = max(intervals[i][1], intervals[i - 1][1])
intervals[i][1] = max(intervals[i][1], intervals[i - 1][1])
#不重叠
else:
ans.append([start, end])
start = intervals[i][0] #不重叠，更新区间数组
end = intervals[i][1]
ans.append([start, end])
return ans738. 单调递增的数字
当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。
给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。
解题思路
这个思路比较好想，但是代码有点难写。具体思路就是将数字从尾到头遍历，如果靠后的数字小于靠前的数字，那么靠后的数字就要变为9，靠前的数字就要减一，这样才满足单调递增的要求。代码如下：
class Solution:
def monotoneIncreasingDigits(self, n: int) -> int:
n_s = str(n)
index = len(n_s) #用于标记需要换为9的位置
#不是单调递增
for i in range(1, len(n_s)):
if n_s[len(n_s) - i] < n_s[len(n_s) - i - 1]:
index = len(n_s) - i
n_s = n_s[:len(n_s) - i - 1] + str(int(n_s[len(n_s) - i - 1]) - 1) + n_s[len(n_s) - i:]
for i in range(index, len(n_s)):
n_s = n_s[:i] + '9' + n_s[i + 1:]
ans = int(n_s)
return ans关于字符串的操作还是不太熟练，还要继续练习。
