2402. 会议室 III

最新推荐文章于 2024-10-06 14:10:45 发布

yinhua405

最新推荐文章于 2024-10-06 14:10:45 发布

阅读量428

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/yinhua405/article/details/131099615

版权

该问题涉及对会议室的高效分配算法，使用优先级队列来管理会议的开始和结束时间，确保最小编号的会议室优先分配，并处理会议延期情况。通过比较每个会议室的使用次数找到最繁忙的会议室。

摘要由CSDN通过智能技术生成

给你一个整数 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 <= 100
1 <= meetings.length <= 105
meetings[i].length == 2
0 <= starti < endi <= 5 * 105
starti 的所有值 互不相同

int mostBooked(int n, vector<vector<int>>& meetings)
{
   if (meetings.size() == 0)
   {
       return 0;
   }
   sort(meetings.begin(), meetings.end(), [](auto &a, auto &b) { return a[0] < b[0]; });
   priority_queue<pair<long, int>, vector<pair<long, int>>, greater<>> min_heap;//结束时间，最小房间
   priority_queue<int, vector<int>, greater<int>> aviRoot;//在此时可用的房间
   for (int i = 0; i < n; i++)
   {
       min_heap.push(pair<long, int>(0, i));
       //aviRoot.push(i);
   }
   int cur = 0;
   int size = meetings.size();
   map<int, int>rootCountMap;// 房间，次数
   map<int, int>rootendTimeMap;//房间，结束时间
   set<int> endTimeSet;//结束时间
   endTimeSet.insert(0);
   map<int, set<int>>endTimeRoot;//结束时间，房间
   for (int roomI = 0; roomI < n; roomI++)
   {
       rootCountMap[roomI] = 0;
   }

   while (cur < size)
   {
       long start = meetings[cur][0];
       long end = meetings[cur][1];
       int num = -1;
       while(!min_heap.empty() && min_heap.top().first <= start)
       {
           aviRoot.push(min_heap.top().second);
           min_heap.pop();
       }

       if (aviRoot.empty() && !min_heap.empty())
       {
           pair<long, int> tmp = min_heap.top();
           min_heap.pop();
           rootCountMap[tmp.second]++;
           if (start < tmp.first)
           {
               min_heap.emplace(tmp.first +end-start, tmp.second);
           }
           else
           {
               min_heap.emplace(end, tmp.second);
           }
       }
       else
       {
           num = aviRoot.top();
           aviRoot.pop();
           rootCountMap[num]++;
           min_heap.emplace(end, num);

       }
       cur++;
   }
   int ret = 0;
   int maxCount = 0;
   for (auto it : rootCountMap)
   {
       if (it.second>maxCount)
       {
           maxCount = it.second;
           if (ret < it.first)
           {
               ret = it.first;
           }
       }
   }