Maximize Win From Two Segments

Maximize Win From Two Segments - Problem

There are some prizes on the X-axis. You are given an integer array prizePositions that is sorted in non-decreasing order, where prizePositions[i] is the position of the ith prize. There could be different prizes at the same position on the line.

You are also given an integer k.

You are allowed to select two segments with integer endpoints. The length of each segment must be k. You will collect all prizes whose position falls within at least one of the two selected segments (including the endpoints of the segments).

The two selected segments may intersect.

For example if k = 2, you can choose segments [1, 3] and [2, 4], and you will win any prize i that satisfies 1 <= prizePositions[i] <= 3 or 2 <= prizePositions[i] <= 4.

Return the maximum number of prizes you can win if you choose the two segments optimally.

Input & Output

Example 1 — Basic Case

$ Input: prizePositions = [1,1,2,2,3,3,5], k = 2

› Output: 7

💡 Note: Choose segments [1,3] and [3,5]. Segment [1,3] covers prizes at positions 1,1,2,2,3,3 (6 prizes). Segment [3,5] covers prizes at positions 3,3,5 (3 prizes). Union covers all 7 prizes at positions 1,1,2,2,3,3,5.

Example 2 — Non-overlapping Optimal

$ Input: prizePositions = [1,2,3,4], k = 1

› Output: 4

💡 Note: Choose segments [1,2] and [3,4]. First segment covers positions 1,2 (2 prizes), second segment covers positions 3,4 (2 prizes). Total: 4 prizes.

Example 3 — Single Position Multiple Prizes

$ Input: prizePositions = [1,1,1,1], k = 0

› Output: 4

💡 Note: Both segments can cover position [1,1], capturing all 4 prizes at position 1.

Constraints

1 ≤ prizePositions.length ≤ 10⁵
1 ≤ prizePositions[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
prizePositions is sorted in non-decreasing order

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to optimize segment selection by precomputing maximum obtainable prizes from each position and using efficient boundary detection. Best approach uses sliding window with precomputation for O(n²) time complexity, or binary search optimization for O(n log n). Space: O(n)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force - Try All Segment Pairs

⏱️ Time: O(n³) Space: O(1)

For each possible first segment starting position, try every possible second segment starting position. Count all prizes covered by the union of both segments.

Sliding Window with Precomputation

⏱️ Time: O(n²) Space: O(n)

For each possible first segment, use sliding window technique to count prizes. Pre-compute the maximum prizes obtainable from any segment starting at or after each position to optimize second segment selection.

Two-Pass with Binary Search

⏱️ Time: O(n log n) Space: O(n)

Optimize the sliding window approach by using binary search to quickly find segment boundaries. Pre-compute maximum obtainable prizes from each position and use binary search for efficient lookups.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

856 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen