大家好，我是挨打的阿木木，爱好算法的前端摸鱼老。最近会频繁给大家分享我刷算法题过程中的思路和心得。如果你也是想提高逼格的摸鱼老，欢迎关注我，一起学习。
题目
1801. 积压订单中的订单总数
给你一个二维整数数组 orders ，其中每个 orders[i] = [pricei, amounti, orderTypei] 表示有 amounti 笔类型为 orderTypei 、价格为 pricei 的订单。
订单类型 orderTypei 可以分为两种：
0表示这是一批采购订单buy1表示这是一批销售订单sell
注意，orders[i] 表示一批共计 amounti 笔的独立订单，这些订单的价格和类型相同。对于所有有效的 i ，由 orders[i] 表示的所有订单提交时间均早于 orders[i+1] 表示的所有订单。
存在由未执行订单组成的 积压订单 。积压订单最初是空的。提交订单时，会发生以下情况：
- 如果该订单是一笔采购订单
buy，则可以查看积压订单中价格 最低 的销售订单sell。如果该销售订单sell的价格 低于或等于 当前采购订单buy的价格，则匹配并执行这两笔订单，并将销售订单sell从积压订单中删除。否则，采购订单buy将会添加到积压订单中。 - 反之亦然，如果该订单是一笔销售订单
sell，则可以查看积压订单中价格 最高 的采购订单buy。如果该采购订单buy的价格 高于或等于 当前销售订单sell的价格，则匹配并执行这两笔订单，并将采购订单buy从积压订单中删除。否则，销售订单sell将会添加到积压订单中。
输入所有订单后，返回积压订单中的 订单总数 。由于数字可能很大，所以需要返回对 109 + 7 取余的结果。
示例 1：
输入： orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]
输出： 6
解释： 输入订单后会发生下述情况：
- 提交 5 笔采购订单，价格为 10 。没有销售订单，所以这 5 笔订单添加到积压订单中。
- 提交 2 笔销售订单，价格为 15 。没有采购订单的价格大于或等于 15 ，所以这 2 笔订单添加到积压订单中。
- 提交 1 笔销售订单，价格为 25 。没有采购订单的价格大于或等于 25 ，所以这 1 笔订单添加到积压订单中。
- 提交 4 笔采购订单，价格为 30 。前 2 笔采购订单与价格最低（价格为 15）的 2 笔销售订单匹配，从积压订单中删除这 2 笔销售订单。第 3 笔采购订单与价格最低的 1 笔销售订单匹配，销售订单价格为 25 ，从积压订单中删除这 1 笔销售订单。积压订单中不存在更多销售订单，所以第 4 笔采购订单需要添加到积压订单中。
最终，积压订单中有 5 笔价格为 10 的采购订单，和 1 笔价格为 30 的采购订单。所以积压订单中的订单总数为 6 。
示例 2：
输入： orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]
输出： 999999984
解释： 输入订单后会发生下述情况：
- 提交 109 笔销售订单，价格为 7 。没有采购订单，所以这 109 笔订单添加到积压订单中。
- 提交 3 笔采购订单，价格为 15 。这些采购订单与价格最低（价格为 7 ）的 3 笔销售订单匹配，从积压订单中删除这 3 笔销售订单。
- 提交 999999995 笔采购订单，价格为 5 。销售订单的最低价为 7 ，所以这 999999995 笔订单添加到积压订单中。
- 提交 1 笔销售订单，价格为 5 。这笔销售订单与价格最高（价格为 5 ）的 1 笔采购订单匹配，从积压订单中删除这 1 笔采购订单。
最终，积压订单中有 (1000000000-3) 笔价格为 7 的销售订单，和 (999999995-1) 笔价格为 5 的采购订单。所以积压订单中的订单总数为 1999999991 ，等于 999999984 % (109 + 7) 。
提示：
1 <= orders.length <= 105orders[i].length == 31 <= pricei, amounti <= 109orderTypei为0或1
思路
这道题目文字比较多，给大家翻译一下题目： 现在我们手头上有一批订单，分别是采购订单和销售订单。当我们拿到一份采购订单时，从库里面找能卖最多钱的销售订单卖掉，当然如果库里能卖最多钱的订单比我们采购价格还低，我们就囤着不卖了，不卖就不会亏。反之拿到销售订单时，从库里拿最便宜的采购订单，成本越低越好，如果成本比我们的价格还高，那我们也囤着，不买了。
- 我们可以分别用两个优先队列来实现对销售订单和采购订单的存储。首先用最大堆来存储销售订单，因为我们卖的钱越多越好，然后用最小堆来存储采购订单，成本越低越好；
- 每次拿到订单，判断是销售订单还是采购订单， 如果是销售订单的话， 拿出最便宜的采购订单，然后判断采购订单的价格是否小于销售订单的价格，只要不亏本我们就进行消除；
- 消除的时候判断一下，这一份采购订单够不够我们的销售订单消费，如果有10份销售订单，而采购订单只有5份，那么先消除5份，然后再拿第二便宜的采购订单进行比较，直到销售订单全部消除完或者没有更便宜的采购订单；
- 当没有更便宜的采购订单的时候，我们要把剩余的销售订单放到销售订单的优先队列中去；
- 如果是采购订单的话， 拿出最贵的销售订单，然后判断销售订单的价格是否大于采购订单的价格，只要不亏本我们就进行消除；
- 消除的判断逻辑跟销售订单一致，如果当前不够就继续下一轮，没有下一轮就存到采购堆里面；
- 最后全部订单过一遍，统计库存还有多少残留即可。
实现
/**
* @param {number[][]} orders
* @return {number}
*/
var getNumberOfBacklogOrders = function(orders) {
// 买的价格越便宜越好
const sellQueue = new MinPriorityQueue({ priority: (bid) => bid.price });
// 卖的价格越高越好
const buyQueue = new MaxPriorityQueue({ priority: (bid) => bid.price });
const n = orders.length;
for (let i = 0; i < n; i++) {
let [ price, amount, orderType ] = orders[i]
// 判断是采购订单还是销售订单
if (orderType === 0) {
while (!sellQueue.isEmpty() && amount && sellQueue.front().element.price <= price) {
let cur = sellQueue.dequeue().element;
// 判断够不够消除，不够的话还要进行下一轮
if (cur.amount > amount) {
cur.amount -= amount;
sellQueue.enqueue(cur);
amount = 0;
} else {
amount -= cur.amount;
}
}
if (amount > 0) {
buyQueue.enqueue({ price, amount });
}
} else {
while (!buyQueue.isEmpty() && amount && buyQueue.front().element.price >= price) {
let cur = buyQueue.dequeue().element;
if (cur.amount > amount) {
cur.amount -= amount;
buyQueue.enqueue(cur);
amount = 0;
} else {
amount -= cur.amount;
}
}
if (amount > 0) {
sellQueue.enqueue({ price, amount });
}
}
}
let result = 0;
// 统计采购订单的残留
while (!buyQueue.isEmpty()) {
result += buyQueue.dequeue().element.amount;
}
// 统计销售订单的残留
while (!sellQueue.isEmpty()) {
result += sellQueue.dequeue().element.amount;
}
const mod = Math.pow(10, 9) + 7;
return result % mod;
};
优化
首先上面统计库存这一步，我们可以放到操作的时候一起统计了，就不用全部操作完还得遍历两个库存。其次我们两个部分的相似代码可以抽离成公共方法，让代码尽可能优雅。
优化代码
/**
* @param {number[][]} orders
* @return {number}
*/
var getNumberOfBacklogOrders = function(orders) {
// 买的价格越便宜越好
const sellQueue = new MinPriorityQueue({ priority: (bid) => bid.price });
// 卖的价格越高越好
const buyQueue = new MaxPriorityQueue({ priority: (bid) => bid.price });
let result = 0;
const n = orders.length;
for (let i = 0; i < n; i++) {
// 判断是采购订单还是销售订单
if (orders[i][2] === 0) {
result = handleAddOrder(sellQueue, buyQueue, result, orders[i]);
} else {
result = handleAddOrder(buyQueue, sellQueue, result, orders[i]);
}
}
const mod = Math.pow(10, 9) + 7;
return result % mod;
};
// 处理新增订单的逻辑
function handleAddOrder(getQueue, setQueue, result, order) {
let [ price, amount, orderType ] = order;
// 这一步是核心，把大于等于转换成小于等于
let base = orderType ? 1 : -1;
while (!getQueue.isEmpty() && amount && getQueue.front().element.price * base >= price * base) {
let cur = getQueue.dequeue().element;
// 够消除了，数量减掉即可
if (cur.amount > amount) {
cur.amount -= amount;
getQueue.enqueue(cur);
result -= amount;
amount = 0;
} else {
// 不够消除，可能还要进行下一轮
amount -= cur.amount;
result -= cur.amount;
}
}
// 找不到适合消除的了，囤起来
if (amount > 0) {
result += amount;
setQueue.enqueue({ price, amount });
}
return result;
}
看懂了的小伙伴可以点个关注、咱们下道题目见。如无意外以后文章都会以这种形式，有好的建议欢迎评论区留言。
