[leetcode][1801]积压订单中的订单总数

方法一：优先队列

思路与算法

积压订单用优先队列表示，因为需要删除买的价格贵和卖的价格低的订单，因此用优先队列。
采购订单按照买入的价格降序，优先删除贵的；销售订单按照升序，优先删除价格低的。
需要注意比较当前订单和队列头部的数量，选择两者较小的值，并且把剩余的数量分别放回买卖的两个队列。

代码

class Solution {
    public int getNumberOfBacklogOrders(int[][] orders) {
        int MOD = 1000000007;
        // 采购订单优先级队列，按照价格降序
        PriorityQueue<int[]> buyOrders = new PriorityQueue<>((a, b) -> b[0] - a[0]);
        // 销售队列按照价格升序
        PriorityQueue<int[]> sellOrders = new PriorityQueue<>((a, b) -> a[0] - b[0]);
        for (int[] order : orders) {
            int price = order[0], amount = order[1], type = order[2];
            if (type == 0) {
                while (amount > 0 && !sellOrders.isEmpty() && sellOrders.peek()[0] <= price) {
                    // 删除订单
                    int[] sellOrder = sellOrders.poll();
                    // 数量为两者中数量少的一边
                    int sellAmount = Math.min(amount, sellOrder[1]);
                    amount -= sellAmount;
                    sellOrder[1] -= sellAmount;
                    // 剩余订单重新入队
                    if (sellOrder[1] > 0) {
                        sellOrders.offer(sellOrder);
                    }
                }
                // 当前订单入队
                if (amount > 0) {
                    buyOrders.offer(new int[]{price, amount});
                }
            } else {
                while (amount > 0 && !buyOrders.isEmpty() && buyOrders.peek()[0] >= price) {
                    // 删除订单
                    int[] buyOrder = buyOrders.poll();
                    // 数量为两者中数量少的一边
                    int buyAmount = Math.min(amount, buyOrder[1]);
                    amount -= buyAmount;
                    buyOrder[1] -= buyAmount;
                    // 剩余订单重新入队
                    if (buyOrder[1] > 0) {
                        buyOrders.offer(buyOrder);
                    }
                }
                // 当前订单入队
                if (amount > 0) {
                    sellOrders.offer(new int[]{price, amount});
                }
            }
        }

        // 求答案
        int res = 0;
        for (PriorityQueue<int[]> pq : Arrays.asList(buyOrders, sellOrders)) {
            while (!pq.isEmpty()) {
                int[] order = pq.poll();
                res = (res + order[1]) % MOD;
            }
        }
        return res;
    }
}

复杂度分析

时间复杂度：O(nlogn)，优先级队列，遍历n个元素，每个元素处理时间为logn。
空间复杂度：O(n)，队列的大小为元素个数。