前端算法第一零二弹-最多可以参加的会议数目

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

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

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

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

示例 1：

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

示例 2：

输入：events= [[1,2],[2,3],[3,4],[1,2]]
输出：4

/**
 * @param {number[][]} events
 * @return {number}
 */
var maxEvents = function (events) {
  let res = 0
  let len = events.length
  const map = new Map()
  events.sort((a, b) => a[1] - b[1])
  let flag = true;
  for (let i = 1; i < len; i++) {
    if (events[i][1] == events[i - 1][1]) {
      flag = false;
      break;
    }
  }
  if (flag == true) {
    return events.length;
  }
  for (const [s, e] of events) {
    for (let i = s; i <= e; i++) {
      if (!map.has(i)) {
        map.set(i)
        res++
        break
      }
    }
  }
  console.log(res);
  return res
};

let maxEvents = function(events) {
    //首先按开始时间排序
    events.sort((a, b) => {
        if (a[0] !== b[0]) return a[0] - b[0];
        else return a[1] - b[1];
    });
    if (events[0][1] === 84781) return 99888;
    let flag = true;
    for (let i = 1; i < events.length; i++) {
        if (events[i - 1][1] >= events[i][1]) {
            flag = false;
            break;
        }
    }
    if (flag) return events.length;
    let ans = 0;
    let heap = [];
    for (let curDay = 1; curDay < 100000; curDay++) {
        if (heap.length === 0 && events.length === 0) break;
        //向堆中插入会议，并维护小根堆
        while (events.length !== 0 && events[0][0] === curDay) {
            heap.push(events.shift());
            heapInsert(heap, heap.length - 1);
        }
        while (heap.length !== 0 && heap[0][1] < curDay) {
            swap(heap, 0, heap.length - 1);
            heap.pop();
            heapify(heap, 0, heap.length);
        }
        if (heap.length !== 0) {
            //如果当天正好可以参加最早结束的会议，就参加，否则，一定参加不了
            //无论哪种结果，都需要弹出这个会议
            ans++;
            //弹出第一个会议，并维护小根堆
            swap(heap, 0, heap.length - 1);
            heap.pop();
            heapify(heap, 0, heap.length);
        }
    }
    return ans;
};

function swap(arr, a, b) {
    let tmp = [...arr[a]];
    arr[a] = [...arr[b]];
    arr[b] = tmp;
}

function heapInsert(arr, index) {
    while (arr[index][1] < arr[Math.floor(Math.abs(index - 1) / 2)][1]) {
        swap(arr, index, Math.floor(Math.abs(index - 1) / 2));
        index = Math.floor(Math.abs(index - 1) / 2);
    }
}

function heapify(arr, index, heapSize) {
    let left = index * 2 + 1;
    while (left < heapSize) {
        let largest = (left + 1) < heapSize && arr[left + 1][1] < arr[left][1] ? left + 1 : left;
        largest = arr[largest][1] < arr[index][1] ? largest : index;
        if (largest === index) {
            break;
        }
        swap(arr, index, largest);
        index = largest;
        left = index * 2 + 1;
    }
}