Maximize Win From Two Segments - Practice Coding Problems

Maximize Win From Two Segments - Problem

Imagine you're planning a treasure hunt along a straight path! 🏴‍☠️

You have an array prizePositions that shows where prizes are located on the X-axis, sorted in non-decreasing order. Multiple prizes can exist at the same position. You're also given an integer k representing the length of segments you can choose.

Your mission: Select exactly two segments, each of length k, to maximize the number of prizes you can collect. You win any prize whose position falls within at least one of your chosen segments (including endpoints).

Key points:

Each segment has length k with integer endpoints
The two segments can overlap - this might be optimal!
A prize at position p is won if it falls in segment [a, a+k] when a ≤ p ≤ a+k

Example: If k = 2, segments [1, 3] and [2, 4] would collect prizes at positions 1, 2, 3, and 4.

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: Choose segments [1,3] and [1,3] (overlapping). The first segment covers prizes at positions 1,1,2,2,3,3 (6 prizes), and the second segment covers the same prizes. Since they overlap completely, we get all 7 prizes total (including the prize at position 5 is not optimal, so we choose segments [1,3] and [3,5] to get prizes at 1,1,2,2,3,3,5).

example_2.py — Non-overlapping Optimal

$ Input: prizePositions = [1,2,3,4,5,6,7,8,9,10], k = 2

› Output: 6

💡 Note: Choose segments [1,3] and [8,10]. First segment covers positions 1,2,3 (3 prizes) and second segment covers positions 8,9,10 (3 prizes). Total = 6 prizes. This is better than overlapping segments.

example_3.py — All Same Position

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

› Output: 5

💡 Note: With k=0, each segment has length 0, so can only cover one position. Both segments cover position 1, getting all 5 prizes at that position.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Survey the Coast

You see treasures at positions [1,1,2,2,3,3,5] and have two nets of length k=2

Plan First Net

Calculate the best position for your first net at each location

Deploy Second Net

For each second net position, find the best first net that doesn't interfere

Maximize Treasure

Combine both nets optimally to collect maximum treasures

Key Takeaway

🎯 Key Insight: The optimal solution uses dynamic programming to precompute the best first segment ending at each position, then combines it with a sliding window approach to efficiently evaluate all possible second segment positions. This reduces time complexity from O(n³) to O(n)!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a sliding window technique combined with dynamic programming. We maintain a DP array where dp[i] represents the maximum prizes achievable with the first segment ending at or before position i. For each possible second segment, we use the sliding window to efficiently count prizes and combine it with the best non-overlapping first segment from our DP array. This achieves O(n) time complexity - much better than the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n³)	O(n)	Try every possible pair of segment positions and count prizes
Sliding Window + Dynamic Programming (Optimal)	O(n)	O(n)	Optimal solution using sliding window and DP to track best first segments
Sliding Window + Binary Search	O(n²)	O(n)	Use sliding window for segments and binary search to find optimal combinations

Brute Force (Try All Combinations) — Algorithm Steps

Iterate through all possible starting positions for first segment
For each first segment, iterate through all possible second segment positions
Count unique prizes covered by both segments using a set
Track the maximum count across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First Segment

Try segment starting at each prize position

Choose Second Segment

For each first segment, try all possible second segments

Count Prizes

Count unique prizes covered by both segments

Track Maximum

Keep track of the best combination found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int maximizeWin(int* prizePositions, int n, int k) {
    int maxPrizes = 0;
    
    // Try all possible positions for first segment
    for (int i = 0; i < n; i++) {
        int seg1End = prizePositions[i] + k;
        
        // Try all possible positions for second segment
        for (int j = 0; j < n; j++) {
            int seg2End = prizePositions[j] + k;
            
            // Count unique prizes (simplified - count total for demo)
            int count = 0;
            int* covered = (int*)calloc(10001, sizeof(int));
            
            // Mark prizes from both segments
            for (int idx = 0; idx < n; idx++) {
                int pos = prizePositions[idx];
                if ((pos >= prizePositions[i] && pos <= seg1End) ||
                    (pos >= prizePositions[j] && pos <= seg2End)) {
                    if (!covered[pos]) {
                        covered[pos] = 1;
                        count++;
                    }
                }
            }
            
            if (count > maxPrizes) {
                maxPrizes = count;
            }
            free(covered);
        }
    }
    
    return maxPrizes;
}

int main() {
    int prizes[] = {1,1,2,2,3,3,5};
    int k = 2;
    printf("%d\n", maximizeWin(prizes, 7, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) combinations of segment pairs, O(n) to count prizes for each pair

⚠ Quadratic Growth

Space Complexity

O(n)

Space for set to store unique prize positions for counting

⚡ Linearithmic Space

34.4K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler