给你一个整数 n ，共有编号从 0 到 n - 1 的 n 个会议室。
给你一个二维整数数组 meetings ，其中 meetings[i] = [starti, endi] 表示一场会议将会在 半闭 时间区间 [starti, endi) 举办。所有 starti 的值 互不相同 。
会议将会按以下方式分配给会议室：
- 每场会议都会在未占用且编号 最小 的会议室举办。
- 如果没有可用的会议室，会议将会延期，直到存在空闲的会议室。延期会议的持续时间和原会议持续时间 相同 。
- 当会议室处于未占用状态时，将会优先提供给原 开始 时间更早的会议。
返回举办最多次会议的房间 编号 。如果存在多个房间满足此条件，则返回编号 最小 的房间。
半闭区间 [a, b) 是 a 和 b 之间的区间，包括 a 但不包括 b 。
示例 1：
输入：n = 2, meetings = [[0,10],[1,5],[2,7],[3,4]]
输出：0
解释：
- 在时间 0 ，两个会议室都未占用，第一场会议在会议室 0 举办。
- 在时间 1 ，只有会议室 1 未占用，第二场会议在会议室 1 举办。
- 在时间 2 ，两个会议室都被占用，第三场会议延期举办。
- 在时间 3 ，两个会议室都被占用，第四场会议延期举办。
- 在时间 5 ，会议室 1 的会议结束。第三场会议在会议室 1 举办，时间周期为 [5,10) 。
- 在时间 10 ，两个会议室的会议都结束。第四场会议在会议室 0 举办，时间周期为 [10,11) 。
会议室 0 和会议室 1 都举办了 2 场会议，所以返回 0 。 示例 2：
输入：n = 3, meetings = [[1,20],[2,10],[3,5],[4,9],[6,8]]
输出：1
解释：
- 在时间 1 ，所有三个会议室都未占用，第一场会议在会议室 0 举办。
- 在时间 2 ，会议室 1 和 2 未占用，第二场会议在会议室 1 举办。
- 在时间 3 ，只有会议室 2 未占用，第三场会议在会议室 2 举办。
- 在时间 4 ，所有三个会议室都被占用，第四场会议延期举办。
- 在时间 5 ，会议室 2 的会议结束。第四场会议在会议室 2 举办，时间周期为 [5,10) 。
- 在时间 6 ，所有三个会议室都被占用，第五场会议延期举办。
- 在时间 10 ，会议室 1 和 2 的会议结束。第五场会议在会议室 1 举办，时间周期为 [10,12) 。
会议室 1 和会议室 2 都举办了 2 场会议，所以返回 1 。 提示：
1 <= n <= 1001 <= meetings.length <= 10^5meetings[i].length == 20 <= starti < endi <= 5 * 10^5starti的所有值 互不相同
分析：用两个优先队列模拟会议室进行会议的过程，队列里的元素结构体记录两个值：会议室的编号 ind，和该会议室最早能开始会议的时间 times。一个队列代表可以进行会议的会议室，另一个代表之前进行过会议的会议室。用一个答案数组，记录编号为 i 的会议室进行过的会议数量。
遍历 meetings 数组。先检查以前进行过会议的会议室，如果最早可以开始会议的时间在当前会议的开始时间之前，则将该会议室放到可进行会议的队列。检查完之后，取出可进行会议的队列中的第一个会议室，修改它的最早可进行会议时间，放入进行过会议的会议室。遍历完 meetings 数组后找到第一个进行过最多会议的会议室编号即为答案。
cpp
class Solution {
public:
typedef struct node{
long long times;
int ind;
}node;
struct cmp_1{
bool operator()(const node &a, const node &b)const{
if(a.times!=b.times)return a.times>b.times; // times 小的优先
return a.ind>b.ind; // times 相同，ind 小的优先
}
};
struct cmp_2{
bool operator()(const node &a, const node &b)const{
return a.ind>b.ind; // times 相同，ind 小的优先
}
};
int mostBooked(int n, vector<vector<int>>& meetings) {
int len=meetings.size(),ans=0,sum=0;
int cnt[110]={0};
priority_queue<node,vector<node>,cmp_1>pq_2;
priority_queue<node,vector<node>,cmp_2>pq_1;
for(int i=0;i<n;++i)
{
node temp;temp.times=0,temp.ind=i;
pq_1.push(temp);
}
sort(meetings.begin(), meetings.end(),
[](const vector<int> &a, const vector<int> &b) {
if (a[0]!=b[0]) return a[0]<b[0];
return a[1]<b[1];
});
for(int i=0;i<len;++i)
{
long long start=meetings[i][0],last=meetings[i][1];
if(!pq_2.empty())
{
while(!pq_2.empty())
{
node temp_2=pq_2.top();
if(temp_2.times<=start)
{
temp_2.times=max(temp_2.times,start);
pq_2.pop(),pq_1.push(temp_2);
}
else break;
}
if(pq_1.empty())
{
node temp_2=pq_2.top();pq_2.pop(),
pq_1.push(temp_2);
}
}
node temp_1=pq_1.top();temp_1.times=max(temp_1.times+last-start,last),cnt[temp_1.ind]++;pq_1.pop();
pq_2.push(temp_1);
}
sum=cnt[0];
for(int i=1;i<n;++i)
if(cnt[i]>sum)sum=cnt[i],ans=i;
return ans;
}
};