题目介绍

给你一个二维整数数组 orders ，其中每个 orders[i] = [pricei, amounti, orderTypei] 表示有 amounti 笔类型为 orderTypei 、价格为 pricei 的订单。

订单类型 orderTypei 可以分为两种：

0 表示这是一批采购订单 buy 1 表示这是一批销售订单 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) 。

来源：力扣（LeetCode）链接：leetcode-cn.com/problems/nu… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

最大堆和最小堆思路，定义一个最小堆存储销售订单，定一个最大堆存储采购订单
根据题目描述，如果采购订单就是在销售订单中找到比采购订单价格低或者相等的订单，然后在积压订单中小曲，如果找不到就把当前的订单放到积压订单中，这样就是用循环找到全部的销售订单比当前采购订单的价格小的，然后减去对应的数量，如果减去积压数量还有剩余的话，就把当前的剩余的采购订单放到积压订单中，如果销售订单减去采购订单的数量刚好为0，就弹出这个销售订单
销售订单也是同理
最后遍历销售订单和采购订单得到最终的积压订单

/**
 * @param {number[][]} orders
 * @return {number}
 */
class Heap {
  constructor(heapType, com) {
    // 0是小顶堆，1是大顶堆
    this.heapType = heapType || 0
    this.data = []
    this.com = com || this.defCom
  }
  defCom(val1, val2) {
      if (this.heapType === 0) {
          return val1 > val2
      } else {
          return val1 < val2
      }
  }
  // getTep(ind) {}
  // 向下调
  shiftDown(ind = 0) {
    let n = this.size() - 1
    while (ind * 2 + 1 <= n) {
      let tmp = ind
      // 小顶堆是用大于号 this.data[tmp] > this.data[ind * 2 + 1]， 大顶堆小于号 this.data[tmp] < this.data[ind * 2 + 1]
      if (this.com(this.data[tmp], this.data[ind * 2 + 1])) tmp = ind * 2 + 1
        if (ind * 2 + 2 <= n && this.com(this.data[tmp], this.data[ind * 2 + 2]))
          tmp = ind * 2 + 2
      if (tmp === ind) break
      this.data[tmp] = [this.data[ind], (this.data[ind] = this.data[tmp])][0]
      ind = tmp
    }
  }
  // 向上调整
  shiftUp(idx) {
    let pIdx = null
    while (
        ((pIdx = Math.floor((idx - 1) / 2)),
        // 小顶堆是用大于号 this.data[pIdx] > this.data[idx], 大顶堆用小于号this.data[pIdx] < this.data[idx]
        idx && this.com(this.data[pIdx], this.data[idx]))
      ) {
        this.data[pIdx] = [this.data[idx], (this.data[idx] = this.data[pIdx])][0]
        idx = pIdx
      }

  }
  push(val) {
    this.data.push(val)
    this.shiftUp(this.size() - 1)
  }
  pop() {
    if (this.size() === 0) return
    if (this.size() === 1) {
      return this.data.pop()
    }
    this.data[0] = this.data.pop()
    this.shiftDown(0)
  }
  top() {
    return this.data[0]
  }
  size() {
    return this.data.length
  }
}
var getNumberOfBacklogOrders = function(orders) {
    let sell = new Heap(0, (val1, val2) => {
        return val1[0] > val2[0]
    })
    let buy = new Heap(1, (val1, val2) => {
        return val1[0] < val2[0]
    })
    for (let x of orders) {
        // let [price, amount, orderType] = x
        if (x[2] === 0) {
            while(x[1] !== 0 && sell.size() && sell.top()[0] <= x[0]) {
                let cnt = Math.min(x[1], sell.top()[1])
                x[1] -= cnt
                sell.top()[1] -= cnt
                if (sell.top()[1] === 0) { sell.pop() }
            }
            if (x[1] !== 0) { buy.push(x); }
        } else {
            while (x[1] !== 0 && buy.size() && buy.top()[0] >= x[0]) {
               let cnt = Math.min(x[1], buy.top()[1])
               x[1] -= cnt
               buy.top()[1] -= cnt
               if (buy.top()[1] === 0) { buy.pop() }
            }
            if (x[1] !== 0) { sell.push(x); }
        }
    }
    let sum = 0; let mod = 1000000007;
    for (let x of buy.data) {
        sum = (sum + x[1] ) % mod;
    }
    for (let x of sell.data) {
        sum = (sum + x[1]) % mod;
    }
    return sum
};

[路飞]_1801. 积压订单中的订单总数

题目介绍

解题思路