day33面试100——会议室

会议室1

给定一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，请你判断一个人是否能够参加这里面的全部会议。

示例 1：

输入：intervals = [[0,30],[5,10],[15,20]]
输出：false

示例 2：

输入：intervals = [[7,10],[2,4]]
输出：true

提示：

• 0 <= intervals.length <= 104
• intervals[i].length == 2
• 0 <= starti < endi <= 106

 小垃圾代码

class Solution:
    def canAttendMeetings(self,intervals:List[List[int]])->bool:
        it = sorted(intervals)
        print(it)
        if len(it) <= 1:
            return True
        temp = it[0][1]
        for i in range(1,len(it)):
            if it[i][0]<temp:
                return False
            else:
                temp = it[i][1]
        return True

 Leecode题解uint32

求解思路

按照会议起始时间排序
判断上一个会议的截止时间与下一个会议的起始时间是否交叉， intervals[i-1][1] <= intervals[i][0]

代码 

class Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        # 按照会议的开始时间对区间进行排序
        intervals.sort()
        
        # 使用生成器表达式，检查是否存在会议重叠的情况
        return all(intervals[i-1][1] <= intervals[i][0] for i in range(1, len(intervals)))

整体分析

1. 排序会议区间：

   • 先按照每个会议的开始时间对所有会议区间进行排序。排序后，会议的时间区间按照时间线性排列，这样就可以简单地检查每对相邻会议之间的关系。

2. 检查会议重叠：

   • 遍历排序后的会议列表，检查每对相邻的会议是否有重叠。
   • 对于会议 intervals[i-1] 和 intervals[i]，如果前一个会议的结束时间 intervals[i-1][1] 大于后一个会议的开始时间 intervals[i][0]，则说明会议有重叠，返回 False。
   • 使用 all 函数结合生成器表达式来高效地检查所有相邻会议对是否满足非重叠条件。

3. 返回结果：

   • 如果所有会议都不重叠，返回 True，表示可以参加所有会议。

效率

• 时间复杂度：主要由排序操作决定，时间复杂度为 O(nlog⁡n)O(n \log n)O(nlogn)，其中 nnn 是会议的数量。
• 空间复杂度：由于排序需要额外的空间，以及生成器表达式的使用，总的空间复杂度为 O(1)O(1)O(1)（不考虑输入存储）。

该方法通过首先排序会议时间段，然后检查相邻时间段是否重叠，简单且有效地判断了是否可以参加所有会议。利用排序后直接比较的方法，确保了算法的高效性。

会议室plus

描述 

给你一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，返回 所需会议室的最小数量 。

示例 1：

输入：intervals = [[0,30],[5,10],[15,20]]
输出：2

示例 2：

输入：intervals = [[7,10],[2,4]]
输出：1

提示：

• 1 <= intervals.length <= 104
• 0 <= starti < endi <= 106

小垃圾的垃圾骗分代码

 45 / 79 个通过的测试用例

class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        intervals.sort()
        print(intervals)
        count = 1
        temp = intervals[0][1]
        for i in range(1,len(intervals)):
            if intervals[i][0]<temp:
                count +=1
                temp = intervals[i][1]
        return count

 Leecode题解loick

解题思路

题目就是要统计同一时刻进行的最大会议的数量我们可以把所有的开始时间和结束时间放在一起排序，用cur表示当前进行的会议数量，遍历排序后的时间数组如果是开始时间，cur加1，如果是结束时间，cur减一；在遍历的过程中，cur出现的最大值就是需要的房间数。

代码

class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        # 创建一个事件列表，其中每个开始时间被标记为+1，结束时间被标记为-1。
        events = [(iv[0], 1) for iv in intervals] + [(iv[1], -1) for iv in intervals]
        
        # 按照时间顺序对事件进行排序，先按时间排序，若时间相同则结束事件在前。
        events.sort()
        
        # 初始化所需的最大会议室数量为0
        ans = 0
        
        # 当前正在使用的会议室数量
        cur = 0
        
        # 遍历所有事件
        for _, e in events:
            # 更新当前会议室数量（开始事件+1，结束事件-1）
            cur += e
            
            # 更新所需的最大会议室数量
            ans = max(ans, cur)
        
        # 返回所需的最大会议室数量
        return ans

整体分析

1. 事件转换：

   • 每个会议的开始和结束时间都被视为一个事件。
   • 开始时间的事件用 +1 表示，表示需要一个新的会议室。
   • 结束时间的事件用 -1 表示，表示释放一个会议室。

2. 排序：

   • 将所有事件按照时间排序。如果时间相同，结束事件排在开始事件之前。这是因为在同一时刻结束和开始会议室的情况下，优先处理结束会议室有助于优化会议室使用。

3. 遍历事件：

   • 使用变量 cur 来跟踪当前需要的会议室数量。
   • 遍历事件列表，更新 cur。若为开始事件，则增加一个会议室；若为结束事件，则减少一个会议室。
   • 使用 ans 来记录当前所需的最大会议室数量。

4. 返回结果：

   • 最后，返回 ans，即遍历所有事件过程中所需的最大会议室数量。

效率

• 时间复杂度：主要由排序操作决定，时间复杂度为 O(nlog⁡n)O(n \log n)O(nlogn)，其中 nnn 是会议的数量。
• 空间复杂度：需要存储所有的事件，空间复杂度为 O(n)O(n)O(n)。

该方法通过将每个会议的开始和结束时间转换为事件，并对这些事件进行排序和遍历，成功地找到了最小会议室数量。使用这样的事件驱动模型来解决会议室问题，简单且有效。