主持人调度（二）

class Solution:
    def minmumNumberOfHost(self , n: int, startEnd: List[List[int]]) -> int:
        # write code here
        sort_startend = sorted(startEnd, key = lambda x:x[0])
        hosts =[]
        for it in sort_startend:
            if len(hosts)>0 and it[0] >= hosts[0]:
                heappop(hosts)
            heappush(hosts,it[1])
        return len(hosts)

class Solution:
    def minmumNumberOfHost(self , n: int, startEnd: List[List[int]]) -> int:
        # write code hereq
        #start i 表示活动开始的时间点
        #end_j 表示，当前num个主持人中，最先结束的时间点
        #如果有人活动结束，那么最先结束的主持人借这个活动，结束的时间点顺延
        #如果活动开始的时间点大于当前主持人中最先结束的时间，需要新加一位主持人
        start=sorted([x[0] for x in startEnd])
        end=sorted([x[1] for x in startEnd])
        num=0
        j=0
        for i in range(n):
            if start[i]>=end[j]:
                j+=1
            else:
                num+=1
        return num

class Solution:
    def minmumNumberOfHost(self , n: int, startEnd: List[List[int]]) -> int:
        # write code here
        if n==0 : return 0
        startime = []
        endtime = []
        count = 0
        max_count = -1
        for i in range(n):
            startime.append(startEnd[i][0])
            endtime.append(startEnd[i][1])
        startime.sort()
        endtime.sort()

        i,j = 0, 0
        while i<n and j<n:
            # 区间重叠了count++
            if startime[i] < endtime[j]:
                count += 1
                i += 1
                # count 最大时是需要主持人最多的时候
                max_count = max(count, max_count)
            #活动结束释放资源
            else:
                count -= 1
                j += 1

        return max_count

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 计算成功举办活动需要多少名主持人
# @param n int整型 有n个活动
# @param startEnd int整型二维数组 startEnd[i][0]用于表示第i个活动的开始时间，startEnd[i][1]表示第i个活动的结束时间
# @return int整型
#
class Solution:
    def minmumNumberOfHost(self , n: int, startEnd: List[List[int]]) -> int:
        # write code here
        ## 分离 开始时间和结束时间 start和end 
        start = [i[0] for i in startEnd]
        end = [i[1] for i in startEnd] 
        
        ## 排序 ：如果有交叉，则就需要加一个主持人 
        start.sort()  
        end.sort() 
        
        ## 使用一个循环控制两个数组 
        num = 0 
        end_time = 0 
        for i in range(n): 
            if start[i] >= end[end_time]: 
                end_time += 1   ## 无交叉情况，后移end_time  
            else: 
                num += 1     ## 有交叉，主持人数量 + 1 
        return num 
        
        

from heapq import *

class Solution:
    def minmumNumberOfHost(self , n: int, startEnd: List[List[int]]) -> int:
        # write code here
        pq = []
        startEnd.sort()
        for i in range(len(startEnd)):
            if len(pq)>0 and pq[0]<=startEnd[i][0]:
                heappop(pq)
            heappush(pq,startEnd[i][1])
        return len(pq)