Leetcode Meeting room问题系列 - 2

上面四类咋解决呢，我发现有共同的思路。

1. 首先就是按照start开始升排序，因为时间有先后循序。

sort_list = sorted(lst_time, key = lambda x: x.start)

    定义时间集合list的长度为len_t, 然后循环去取里面的元素(len_t -1个元素)，这个元素的end与后面元素的start比较，咋比较具 体要根据不同的题目。

for i in range(len_t-1):

     lst_time[i].end  lst_time[i+1].start

比如问题2 

    lst_time[i].end > lst_time[i+1].start:

              return False

    return True

那么问题2的完整代码是:

class Solution(object):

    def canAttendMeetings(self, intervals):

        """

        :type intervals: List[Interval]

        :rtype: bool

        """

        intervals_sorted = sorted(intervals, key = lambda x: x.start)

        len_t = len(intervals_sorted)

        lst_f = []

        for i in range(len_t-1):

            if intervals_sorted[i+1].start >= intervals_sorted[i].end:

               lst_f.append(0)

            else:

               lst_f.append(1)

        if sum(lst_f) > 0:

            return False

        else:

            return True

比如问题 1 就是:

比如合并后的集合是

现在循环取排好的时间集合。

for i in  intervals:

如果merged是空的或者最后一个的end < i.start:

       Merged.append(i)

 或者

       Merged[-1].end = max(merged[-1].end, i.end)

return Merged

所有代码就是:

class Solution(object):

    def merge(self, intervals):

        """

        :type intervals: List[Interval]

        :rtype: List[Interval]

        """

        intervals.sort(key=lambda x: x.start)

        merged = []

        for i in intervals:

            if not merged or merged[-1].end < i.start:

               merged.append(i)

            else:

               merged[-1].end = max(merged[-1].end, i.end)

        

        return merged

对于问题3关于会议室最小数目问题，那么怎么解决呢。

 

# 首先第一步还是排序
intervals.sort(key= lambda x: x.start)

然后就是把第一个时间的end放进去

heapq.heappush(free_rooms, intervals[0].end)

然后就是循环取从第二个开始取。

       



     # 这是一个堆的，堆的特点第一个值是最小的值，最后一个值是最大的值。

     # 把第一个元素end放进去啦。  

       heapq.heappush(free_rooms, intervals[0].end)

     # 循环遍历从第二个元素 

　　for i in intervals[1:]:

            # 如果free_room中最小的小于start  

            if free_rooms[0] <= i.start:

            #  删除掉最小的

              heapq.heappop(free_rooms)

            # 如果不小于那就是添加进去  

heapq.heappush(free_rooms, i.end)

       # 最后就是房间数量

         return len(free_rooms)

 

    

关于问题5也是一样的首先就是排序，只是这个list与以前的题目list不同 

       ints = sorted([i for s in schedule for i in s], key=lambda x: x.start)

       res, pre = [], ints[0]

       for i in ints[1:]:

            if i.start <= pre.end and i.end > pre.end:

                  pre.end = i.end

            elif i.start > pre.end:

                     res.append(Interval(pre.end, i.start))

                    pre = i

       return res

 

你发现了解体规律啦吗

关于问题4

class Solution:

    def partitionLabels(self, S: str) -> List[int]:

        last = {c: i for i, c in enumerate(S)}

        j = anchor = 0

        ans = []

        for i, c in enumerate(S):

            j = max(j, last[c])

            if i == j:

                ans.append(i - anchor + 1)

                anchor = i + 1

        return ans