文章提供了三道编程题的解决方案，包括根据给定账单进行柠檬水找零的C++和Java代码，基于身高的队列重建算法，以及用最少箭引爆气球的优化策略。解题思路涉及数组、链表和排序技巧。
目录
1. T860：柠檬水找零
T860：在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
注意，一开始你手头没有任何零钱。
给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
提示：
-
1 <= bills.length <= 105
-
bills[i] 不是 5 就是 10 或是 20
S：懒得废话了，这题太简单了。
C++和Java的代码都完全一样
public boolean lemonadeChange(int[] bills) {
int five = 0, ten = 0;
for (int bill : bills) {
if (bill == 5) ++five;
else if (bill == 10) {
if (five < 1) return false;
++ten;
--five;
} else {
if (ten > 0 && five > 0) {
--ten;
--five;
} else if (five > 2) {
five -= 3;
} else return false;
}
}
return true;
}2. T406：根据身高重建队列
T406：假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。
请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。
提示：
-
1 <= people.length <= 2000
-
0 <= hi <= 106
-
0 <= ki < people.length
S：
本题反映出目前存在的两大问题（注意点）：
-
对STL库中的常用类根本不熟；
-
对cmp排序规则指定函数要熟练！
本题有两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后再按照另一个维度重新排列。如果两个维度一起考虑一定会顾此失彼。
2.1 版本Ⅰ、使用数组
2.1.1 C++：
vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
vector<vector<int>> que;
sort(people.begin(), people.end(), cmp);
for (int i = 0; i < people.size(); ++i) {
int position = people[i][1];
que.insert(que.begin() + position, people[i]);
}
return que;
}
static bool cmp(const vector<int>& p1, const vector<int>& p2) {
if (p1[0] == p2[0]) return p1[1] < p2[1];// 不光按身高排（身高相同k小的站前面）
return p1[0] > p2[0];
}2.1.2 Java：
public int[][] reconstructQueue(int[][] people) {
if (people.length == 1) return people;
Arrays.sort(people, (p1, p2) -> {
if (p1[0] == p2[0]) return p1[1] - p2[1];
return p2[0] - p1[0];
});
List<int[]> res = new ArrayList<>();
for (int[] p : people) {
res.add(p[1], p);
}
return res.toArray(new int[people.length][]);
}但众所周知，数组的优势是查询快，增删慢，因此这里使用链表会更好。
2.2 版本Ⅱ、使用链表
2.2.1 C++：
vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
list<vector<int>> que;// list底层是链表实现，插入效率比vector高的多
sort(people.begin(), people.end(), cmp);
for (int i = 0; i < people.size(); ++i) {
int position = people[i][1];
// ⭐精髓（跟版本Ⅰ的唯一不同点）开始
list<vector<int>>::iterator it = que.begin();// 每轮都要重新获取迭代器
while (position--) ++it;
que.insert(it, people[i]);
//【🚩盲猜：不是所有的迭代器都可以执行四则运算】
// que.insert(que.begin() + position, people[i]);// error，不能像vector那样写
}
return vector<vector<int>>(que.begin(), que.end());
}
static bool cmp(const vector<int>& p1, const vector<int>& p2) {
if (p1[0] == p2[0]) return p1[1] < p2[1];// 不光按身高排（身高相同k小的站前面）
return p1[0] > p2[0];
}2.2.2 Java：
1、首先要想明白一个问题，C++中为什么要用迭代器？
——因为insert方法的第一个参数是迭代器，用迭代器的目的是为了在指定的位置插入元素（会改变已有元素的位置，故要用动态数组）；
而Java中则不需要用到迭代器
2、int[] 同样是引用类型，并不属于基本类型（从可以new就可以看得出来），因此可以作为（如容器类的）泛型
public int[][] reconstructQueue(int[][] people) {
if (people.length == 1) return people;
Arrays.sort(people, (p1, p2) -> {
if (p1[0] == p2[0]) return p1[1] - p2[1];
return p2[0] - p1[0];
});
LinkedList<int[]> res = new LinkedList<>();
for (int i = 0; i < people.length; ++i) {
int position = people[i][1];
// Iterator<int[]> it = res.iterator();
// while ()
res.add(position, people[i]);
}
// return res.toArray();// Object[] cannot be converted to int[][]
// return res.toArray(new int[][]);// array dimension missing
return res.toArray(new int[people.length][]);// 第二个[]内写不写，写几都行
}3. T452：用最少数量的箭引爆气球
T452：有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。
一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。
给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。
提示：
-
1 <= points.length <= 105
-
points[i].length == 2
-
-231 <= xstart < xend <= 231 - 1
S：本题看似是二维，实际上是一维的；
如果要明确说难点在哪里，倒也不好说，总得来说就是这整套流程得理得顺。
3.1 版本Ⅰ、从前往后（最顺版）
C++：
int findMinArrowShots(vector<vector<int>>& points) {
if (points.size() == 1) return 1;
sort(points.begin(), points.end(), cmp);
int res = 1;
for (int i = 1; i < points.size(); ++i) {
// 气球不挨着，必须要多一箭
if (points[i][0] > points[i - 1][1]) {// 注意不要带上=
++res;
} else {// 气球i和气球i-1挨着
// 更新重叠气球最小右边界
points[i][1] = min(points[i - 1][1], points[i][1]);
}
}
return res;
}
static bool cmp(const vector<int>& point1, const vector<int>& point2) {
return point1[0] < point2[0];
}Java：
public int findMinArrowShots(int[][] points) {
if (points.length == 1) return 1;
// Arrays.sort(points, (p1, p2) -> p1[0] - p2[0]);// 作用范围溢出 -> 解答错误
Arrays.sort(points, (p1, p2) -> Integer.compare(p1[0], p2[0]));
int res = 1;
for (int i = 1; i < points.length; ++i) {
if (points[i][0] > points[i - 1][1]) {
++res;
} else {
points[i][1] = Math.min(points[i - 1][1], points[i][1]);
}
}
return res;
}3.2 版本Ⅱ、从后往前
C++：
int findMinArrowShots(vector<vector<int>>& points) {
if (points.size() == 1) return 1;
sort(points.begin(), points.end(), cmp);
int res = 1;
for (int i = points.size() - 2; i >= 0; --i) {
if (points[i][1] < points[i + 1][0]) {
++res;
} else {
points[i][0] = max(points[i][0], points[i + 1][0]);
}
}
return res;
}
static bool cmp(const vector<int>& p1, const vector<int>& p2) {
// return p1[1] > p2[1];
return p1[1] < p2[1];
}Java：
public int findMinArrowShots(int[][] points) {
if (points.length == 1) return 1;
// Arrays.sort(points, (p1, p2) -> p1[1] - p2[1]);
Arrays.sort(points, (p1, p2) -> Integer.compare(p1[1], p2[1]));
int res = 1;
for (int i = points.length - 2; i >= 0; --i) {
if (points[i][1] < points[i + 1][0]) {
++res;
} else {
points[i][0] = Math.max(points[i][0], points[i + 1][0]);
}
}
return res;
}3.3 思考与尝试
其实写的时候就在想了，按照气球的左还是右边界排序，和之后的遍历方向是否有必然联系？
——尝试之后得出结论，并没有关联！比如下面这样：
//按右边界排序 + 从前往后遍历
public int findMinArrowShots(int[][] points) {
if (points.length == 1) return 1;
// Arrays.sort(points, (p1, p2) -> p1[1] - p2[1]);
Arrays.sort(points, (p1, p2) -> Integer.compare(p1[1], p2[1]));
int res = 1;
for (int i = 1; i < points.length; ++i) {
if (points[i][0] > points[i - 1][1]) {
++res;
} else {
points[i][1] = Math.min(points[i - 1][1], points[i][1]);
}
}
return res;
}
//按左边界排序 + 从后往前遍历
public int findMinArrowShots(int[][] points) {
if (points.length == 1) return 1;
Arrays.sort(points, (p1, p2) -> Integer.compare(p1[0], p2[0]));
int res = 1;
for (int i = points.length - 2; i >= 0; --i) {
if (points[i + 1][0] > points[i][1]) {
++res;
} else {
points[i][0] = Math.max(points[i + 1][0], points[i][0]);
}
}
return res;
}
扫一扫
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
