[路飞]_最多可以参加的会议数目

「这是我参与2022首次更文挑战的第8天，活动详情查看：2022首次更文挑战」

1353. 最多可以参加的会议数目

题目

给你一个数组 events，其中 events[i] = [startDayi, endDayi] ，表示会议 i 开始于 startDayi ，结束于 endDayi 。

你可以在满足 startDayi <= d <= endDayi 中的任意一天 d 参加会议 i 。注意，一天只能参加一个会议。

请你返回你可以参加的 最大 会议数目。

示例

输入：events = [[1,2],[2,3],[3,4]]
输出：3
解释：你可以参加所有的三个会议。
安排会议的一种方案如上图。
第 1 天参加第一个会议。
第 2 天参加第二个会议。
第 3 天参加第三个会议。

题解

贪心 + 小顶堆

在满足 startDayi <= d <= endDayi 中的任意一天都可以参加会议
比如events = [[1,2],[1,2]];
你可以在第1天参加会议1，然后第二天参加会议2；不用等到会议1结束再去参加会议2。语文不好，我在这里迷惑了好一会儿。

会议可以在任意一天参加，假设events = [[1,7],[1,5]];对events这个数组，会议1第7天结束，会议2在第5天结束。

所以理论上不同会议相同的开始时间，应该先参加早结束的会议，晚点结束的会议在参加完，还有机会再参加早结束的会议；

• 可以将events根据结束时间升序排列，
• 因为存在相同的结束时间，相同的结束时间，会议开始时间靠前的先参加
  • 比如数组events = [[1,5],[2,5],[3,5]];
  • 会议开始时间靠前的先参加，你可以参加会议1、2、3共3场会议
• 对于不同的会议结束时间，会议结束时间考前的会议先参加
• 从第1场会议开始枚举
• 使用day表示当前会议进行天数，每执行无论参加会议或者不参加会议day+1；
• 对于任意一场会议，如果开始时间小于day,该会议可能可以参加，可以先将其会议的结束时间放入小顶堆中
• 小顶堆为空，并且枚举到最后一场会议，循环结束

根据上述思路编辑代码如下

代码

class Heap {
  constructor(compare) {
    this.list = [0]
    this.compare = typeof compare === 'function' ? compare : this.defaultCompare
  }

  defaultCompare(a, b) {
    return a > b
  }

  swap(x, y) {
    const t = this.list[x]
    this.list[x] = this.list[y]
    this.list[y] = t
  }
  isEmpty() {
    return this.list.length === 1
  }
  getSize() {
    return this.list.length - 1
  }
  top() {
    return this.list[1]
  }

  left(x) {
    return 2 * x
  }
  right(x) {
    return 2 * x + 1
  }
  parent(x) {
    return Math.floor(x / 2)
  }

  push(val) {
    // 新增数据，向堆尾添加
    this.list.push(val)

    this.up(this.list.length - 1)
  }
  // 上浮
  up(k) {
    const { list, parent, compare } = this
    while (k > 1 && compare(list[k], list[parent(k)])) {
      this.swap(parent(k), k)
      k = parent(k)
    }
  }
  pop() {
    const { list } = this
    if (list.length === 0) return null
    this.swap(1, list.length - 1)
    const top = list.pop()
    this.down(1)
    return top
  }

  down(k) {
    const { list, left, right, compare } = this
    const size = this.getSize()
    while (left(k) <= size) {
      let _left = left(k)
      if (right(k) <= size && compare(list[right(k)], list[_left])) {
        _left = right(k)
      }
      if (compare(list[k], list[_left])) return
      this.swap(k, _left)
      k = _left
    }
  }
}

var maxEvents = function (events) {
  events.sort((a, b) => a[0] - b[0])
  // 小顶堆
  const minHeap = new Heap((a, b) => a < b)
  const len = events.length
  let index = 0
  let result = 0
  let end = 1
  while (index < len || !minHeap.isEmpty()) {
    while (index < len && events[index][0] <= end) {
      minHeap.push(events[index][1])
      index++
    }
    while (!minHeap.isEmpty() && minHeap.top() < end) {
      minHeap.pop()
    }
    if (!minHeap.isEmpty()) {
      minHeap.pop()
      result += 1
    }

    end++
  }

  return result
}

结语

感觉本篇文章并没有讲透彻；大概是因为我对本题理解还不够清楚；现在能理解的先记录下来，明天再理解一下，逐步完善。