Two Best Non-Overlapping Events

2054. Two Best Non-Overlapping Events

Difficulty: Medium

Topics: Array, Binary Search, Dynamic Programming, Sorting, Heap (Priority Queue)

You are given a 0-indexed 2D integer array of events where events[i] = [startTime_i, endTime_i, value_i]. The i^th event starts at startTime_i and ends at endTime_i, and if you attend this event, you will receive a value of value_i. 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 5
• events[i].length == 3
• 1 i i 9
• 1 i 6

Hint:

1. How can sorting the events on the basis of their start times help? How about end times?
2. How can we quickly get the maximum score of an interval not intersecting with the interval we chose?

Solution:

We can use the following approach:

Approach

1. Sort Events by End Time:

   • Sorting helps us efficiently find non-overlapping events using binary search.

2. Binary Search for Non-Overlapping Events:

   • Use binary search to find the latest event that ends before the current event's start time. This ensures non-overlapping.

3. Dynamic Programming with Max Tracking:

   • While iterating through the sorted events, maintain the maximum value of events up to the current one. This allows us to quickly compute the maximum sum of two events.

4. Iterate and Calculate the Maximum Sum:

   • For each event, calculate the possible sum using:
     • Only the current event.
     • The current event combined with the best non-overlapping event found using binary search.

Let's implement this solution in PHP: 2054. Two Best Non-Overlapping Events

<?php /**
 * @param Integer[][] $events
 * @return Integer
 */
function maxTwoEvents($events) {
    ...
    ...
    ...
    /**
     * go to ./solution.php
     */
}

// Example Usage:
$events1 = [[1, 3, 2], [4, 5, 2], [2, 4, 3]];
$events2 = [[1, 3, 2], [4, 5, 2], [1, 5, 5]];
$events3 = [[1, 5, 3], [1, 5, 1], [6, 6, 5]];

echo maxTwoEvents($events1) . "\n"; // Output: 4
echo maxTwoEvents($events2) . "\n"; // Output: 5
echo maxTwoEvents($events3) . "\n"; // Output: 8
?>

Explanation:

1. Sorting:

   • The events are sorted by their end time, which allows for efficient searching of the last non-overlapping event.

2. Binary Search:

   • For each event, binary search determines the latest event that ends before the current event starts.

3. Max Tracking:

   • We maintain an array maxUpTo, which stores the maximum value of events up to the current index. This avoids recalculating the maximum for earlier indices.

4. Max Sum Calculation:

   • For each event, calculate the sum of its value and the best non-overlapping event's value. Update the global maximum sum accordingly.

Complexity Analysis

• Sorting: O(n log n)
• Binary Search for Each Event: O(log n), repeated n times → O(n log n)
• Overall: O(n log n)

This solution is efficient and works well within the constraints.

Contact Links

If you found this series helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks ?. Your support would mean a lot to me!

If you want more helpful content like this, feel free to follow me:

• LinkedIn
• GitHub

The above is the detailed content of Two Best Non-Overlapping Events. For more information, please follow other related articles on the PHP Chinese website!