leetcode - 2054. Two Best Non-Overlapping Events

Description

You are given a 0-indexed 2D integer array of events where events $i$ = $startTimei, endTimei, valuei$ . The ith event starts at startTimei and ends at endTimei, and if you attend this event, you will receive a value of valuei. You can choose at most two non-overlapping events to attend such that the sum of their values is maximized.

Return this maximum sum.

Note that the start time and end time is inclusive: that is, you cannot attend two events where one of them starts and the other ends at the same time. More specifically, if you attend an event with end time t, the next event must start at or after t + 1.

Example 1:

复制代码

Input: events = [[1,3,2],[4,5,2],[2,4,3]]
Output: 4
Explanation: Choose the green events, 0 and 1 for a sum of 2 + 2 = 4.

Example 2:

复制代码

Input: events = [[1,3,2],[4,5,2],[1,5,5]]
Output: 5
Explanation: Choose event 2 for a sum of 5.

Example 3:

复制代码

Input: events = [[1,5,3],[1,5,1],[6,6,5]]
Output: 8
Explanation: Choose events 0 and 2 for a sum of 3 + 5 = 8.

Constraints:

复制代码

2 <= events.length <= 10^5
events[i].length == 3
1 <= startTimei <= endTimei <= 10^9
1 <= valuei <= 10^6

Solution

Solved after help...

Heap

Use a min-heap to store events with earlier ending time. When we have a new event, pop from the heap to get non-overlapping events, and stop until the earliest event in heap is over-lapping. Use a variable to store the maximum value during popping, and when we stop, we have a possible maximum pair: with the current one and the maximum one.

We need to sort the events by start time first.

Time complexity: o ( n log ⁡ n ) o(n\log n) o(nlogn)

Space complexity: o ( n ) o(n) o(n)

Greedy

How could someone come up with this solution??? @_@

This is actually similar to heap. So in heap, a key thing we need to do is: use max_val to keep track of all the values of events that end earlier than the current one. So if we flatten the events by its time, and each time when we see a start of an event, we know we could pair it with the most valuable event that ends earlier than it. Each time we see a close of an event, we know we could update the "most valuable event that ends earlier".

To do so, use end_time + 1 as the time for endings, and put it before the start if we have a tie.

Time complexity: o ( n log ⁡ n ) o(n\log n) o(nlogn)

Space complexity: o ( n ) o(n) o(n)

Code

Heap

python3 复制代码

class Solution:
    def maxTwoEvents(self, events: List[List[int]]) -> int:
        # (end_time, val)
        prev_events = []
        events.sort(key=lambda x: x[0])
        res = 0
        max_val = 0
        for start_time, end_time, val in events:
            while prev_events and prev_events[0][0] < start_time:
                _, top_val = heapq.heappop(prev_events)
                max_val = max(max_val, top_val)
            res = max(res, max_val + val)
            heapq.heappush(prev_events, (end_time, val))
        return res

Greedy

python3 复制代码

class Solution:
    def maxTwoEvents(self, events: List[List[int]]) -> int:
        event_items = []
        for start_time, end_time, val in events:
            event_items.append((start_time, 1, val))
            event_items.append((end_time + 1, 0, val))
        event_items.sort()
        res = 0
        max_val = 0
        for event_time, event_type, val in event_items:
            if event_type == 1:
                res = max(res, val + max_val)
            else:
                max_val = max(max_val, val)
        return res