代码随想录算法训练营第三十四天|860. 柠檬水找零、406. 根据身高重建队列、452.用最少数量的箭引爆气球

LeetCode 860. 柠檬水找零
题目链接：860. 柠檬水找零 - 力扣（LeetCode）

​思路：

其实就是人家用20买柠檬水的时候，优先把10块给花了就行。

代码：

#python
class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        charge = {5 : 0, 10 : 0, 20 : 0}
        for bill in bills:
            if bill == 5:
                charge[bill] += 1
            elif bill == 10:
                if charge[5] > 0:
                    charge[10] += 1
                    charge[5] -= 1
                else:
                    return False
            elif bill == 20:
                if charge[10] > 0 and charge[5] > 0:
                    charge[10] -= 1
                    charge[5] -= 1
                elif charge[5] > 2:
                    charge[5] -= 3
                else:
                    return False
        return True

/java
import java.util.HashMap;  
import java.util.Map;  
  
class Solution {  
    public boolean lemonadeChange(int[] bills) {  
        Map<Integer, Integer> map = new HashMap<>();  
        for (int bill : bills) {  
            // 收下当前账单  
            map.put(bill, map.getOrDefault(bill, 0) + 1);  
  
            if (bill == 10) {  
                // 10元需要一张5元找零  
                if (!map.containsKey(5) || map.get(5) == 0) {  
                    // 如果没有5元，无法找零  
                    return false;  
                }  
                // 减去一张5元  
                map.put(5, map.get(5) - 1);  
            } else if (bill == 20) {  
                // 20元需要找零  
                // 优先使用一张10元和一张5元找零  
                if (map.containsKey(10) && map.get(10) > 0 && map.containsKey(5) && map.get(5) > 0) {  
                    map.put(10, map.get(10) - 1);  
                    map.put(5, map.get(5) - 1);  
                } else if (map.containsKey(5) && map.get(5) >= 3) {  
                    // 如果没有10元但有至少三张5元，则减去三张5元  
                    map.put(5, map.get(5) - 3);  
                } else {  
                    // 如果上述条件都不满足，无法找零  
                    return false;  
                }  
            }  
        }  
  
        // 如果所有账单都能成功找零，则返回true  
        return true;  
    }  
}

---

LeetCode 406. 根据身高重建队列
题目链接：406. 根据身高重建队列 - 力扣（LeetCode）

​思路：

这道题是真牛逼，反正我自己想不出来，要从左向右排列，再反向排一次。先根据匿名函数来排序，排完之后插入。

代码：

#python
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

/java
import java.util.*;  
  
class Solution {  
    public int[][] reconstructQueue(int[][] people) {  
        // 先按照h维度的身高顺序从高到低排序，如果身高相同，则根据k维度从小到大排序  
        Arrays.sort(people, new Comparator<int[]>() {  
            @Override  
            public int compare(int[] a, int[] b) {  
                if (a[0] == b[0]) {  
                    return a[1] - b[1]; // 注意Java中Comparator的compare方法要求返回负数表示a<b  
                }  
                return b[0] - a[0]; // 负数表示降序  
            }  
        });  
          
        List<int[]> queue = new ArrayList<>();  
          
        // 根据每个元素的第二个维度k，贪心算法，进行插入  
        for (int[] p : people) {  
            queue.add(p[1], p); // 在指定的索引位置插入元素  
        }  
          
        // 将ArrayList转换为二维数组  
        int[][] result = new int[people.length][2];  
        for (int i = 0; i < people.length; i++) {  
            result[i] = queue.get(i);  
        }  
          
        return result;  
    }  
}

---

LeetCode 452.用最少数量的箭引爆气球
题目链接：452. 用最少数量的箭引爆气球 - 力扣（LeetCode）

​思路：

冲

代码：

#python
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

/java
import java.util.Arrays;  
import java.util.Comparator;  
  
public class Solution {  
    public int findMinArrowShots(int[][] points) {  
        if (points.length == 0) {  
            return 0;  
        }  
  
        // 根据气球的左边界进行排序  
        Arrays.sort(points, new Comparator<int[]>() {  
            @Override  
            public int compare(int[] a, int[] b) {  
                return a[0] - b[0];  
            }  
        });  
  
        int arrows = 1; // 至少需要一支箭  
        int end = points[0][1]; // 初始化当前箭能够射到的最远位置  
  
        for (int i = 1; i < points.length; i++) {  
            // 如果当前气球的左边界已经超过了箭的射程，则需要增加一支箭  
            if (points[i][0] > end) {  
                arrows++;  
                end = points[i][1]; // 更新箭的射程  
            } else {  
                // 否则，更新箭的射程为当前箭射程和当前气球右边界的较小值  
                end = Math.min(end, points[i][1]);  
            }  
        }  
  
        return arrows;  
    }  
}

---