代码随想录刷题第34天|860.柠檬水找零，406.根据身高重建队列，452. 用最少数量的箭引爆气球

860.柠檬水找零

有如下三种情况：

• 情况一：账单是5，直接收下。
• 情况二：账单是10，消耗一个5，增加一个10
• 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        five=0
        ten=0
        twenty=0#一开始都是没钱的

        for bill in bills:
            if bill==5:
                five+=1
            
            if bill==10:
                if five<=0:
                    return False
                ten+=1
                five-=1
            if bill ==20:
                #先使用10美元和5美元找零
                if five>0 and ten>0:
                    five-=1
                    ten-=1
                    twenty+=1#可省略，因为没办法用20找零
                elif five>=3:
                    five-=3
                else:
                    return False
        return True

406.根据身高重建队列

我们可以确定一个维度了，就是身高，前面的节点一定都比本节点高

排序完的people： [[7,0], [7,1], [6,1], [5,0], [5,2]，[4,4]]

插入的过程：

• 插入[7,0]：[[7,0]]
• 插入[7,1]：[[7,0],[7,1]]
• 插入[6,1]：[[7,0],[6,1],[7,1]]
• 插入[5,0]：[[5,0],[7,0],[6,1],[7,1]]
• 插入[5,2]：[[5,0],[7,0],[5,2],[6,1],[7,1]]
• 插入[4,4]：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]

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=[]

        #people已经排序过：同一高度时k值小的排前面
        for p in people:
            que.insert(p[1],p)#这行代码的意思是将数组p中索引为1的元素插入到队列que中。
        
        return que

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

为了让气球尽可能的重叠，需要对数组按照起始位置进行排序。

如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        if len(points)==0:
            return 0
        points.sort(key=lambda x: x[0])#以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],points[i-1][1])
        return result

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        
        points.sort(key=lambda x: x[0])#以x[0为基础进行排序
        sl,sr=points[0][0],points[0][1]
        count=1
        for i in points:
            if i[0]>sr:
                count+=1
                sl,sr=i[0],i[1]
            else:
                s1=max(sl,i[0])
                sr=min(sr,i[1])
        return count