LeetCode-Python-1353. 最多可以参加的会议数目（数组 + 堆 + 贪心）

最新推荐文章于 2024-08-09 15:23:14 发布

暴躁老哥在线刷题

最新推荐文章于 2024-08-09 15:23:14 发布

阅读量1.1k

点赞数 1

分类专栏： Leetcode

本文链接：https://blog.csdn.net/qq_32424059/article/details/104572740

版权

Leetcode 专栏收录该内容

817 篇文章 121 订阅

订阅专栏

给你一个数组 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
示例 3：

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

输入：events = [[1,100000]]
输出：1
示例 5：

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

提示：

1 <= events.length <= 10^5
events[i].length == 2
1 <= events[i][0] <= events[i][1] <= 10^5
通过次数1,899提交次数6,999

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-events-that-can-be-attended
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第一种思路：

贪心法，

先把event按照结束时间排好序，根据贪心的思想优先去结束早的会议。

遍历所有event，对于每个event 再遍历整个区间，如果区间上存在空闲天，那么这一天就去参加当前event。

缺点：比较慢会超时

时间复杂度：O（NlogN + NK)，K是最长区间长度

空间复杂度：O（D）， D是events覆盖的天数范围，在visited这个集合中使用

class Solution(object):
    def maxEvents(self, events):
        """
        :type events: List[List[int]]
        :rtype: int
        """
        if not events:
            return 0
        events = sorted(events, key = lambda x:(x[1]))

        visited = set()
        for i, event in enumerate(events):
            s, e = event[0], event[1]
            for d in range(s, e + 1):
                if d not in visited:
                    visited.add(d)
                    break
        
        return len(visited)

第二种思路：

前一种思路比较慢，因为每个event的每个时间点都遍历了一次，被多个event覆盖的时间点即有可能被多次重复遍历。

考虑到这一点，我们可以优化一下思路：

现在不再从event上进行遍历，而是从题目给出的时间范围【1， 10 ** 5】上进行遍历，判断每一天去参加哪个event。

从每一天的角度出发：

首先我们需要找到在今天还可以被访问的event有哪些，即满足【开始时间在今天或今天之前，并且结束时间在今天或今天之后】的event。

当找到所有满足要求的event的时候，根据贪心的思想，我们应该去结束时间最早的哪个event，因为别的结束时间晚的event可以以后再去。

找结束时间最早的event 的这个过程可以抽象为动态找最小值的问题，因此可以用最小堆解题。

一个可以优化的点在于：event入堆时只需保留结束时间，因为入堆之后我们只在乎结束时间，而堆内元素理应都满足开始时间比今天早或相等的条件。

时间复杂度：O（NlogN + TlogN），T是最晚结束的event的结束时间，N是event个数。

空间复杂度：O（N），当所有event都在队列里时。

class Solution(object):
    def maxEvents(self, events):
        """
        :type events: List[List[int]]
        :rtype: int
        """
        from heapq import *
        if not events:
            return 0
        # 排序并反转，反转是为了可以快速pop，也可利用计数下标进行从小到大进行逐个访问
        events = sorted(events, key = lambda x:(x[0], x[1]))[::-1]
        
        queue = []
        res = 0
        for day in range(1, 10 ** 5 + 1):
            # 把所有结束日期在当前日期之前的event都pop掉
            while queue and queue[0] < day:
                heappop(queue)
            
            # 把所有开始日期大于等于当前日期的event都push进队列
            while events and events[-1][0] <= day:
                last = events.pop()
                heappush(queue, last[1])
            
            # 在这一时刻，queue里存放着所有今天可以去的event
            if queue:
                # 如果当前日期有可以去的event，就去结束时间最早的这一个
                heappop(queue)
                res += 1
            if not queue and not events:
                # 如果所有event都参加完了
                break
        
        return res