Maximum Coins From K Consecutive Bags

Maximum Coins From K Consecutive Bags - Problem

Array Binary Search Greedy Sliding Window Sorting Prefix Sum Medium

There are an infinite amount of bags on a number line, one bag for each coordinate. Some of these bags contain coins.

You are given a 2D array coins, where coins[i] = [l_i, r_i, c_i] denotes that every bag from l_i to r_i (inclusive) contains c_i coins. The segments that coins contain are non-overlapping.

You are also given an integer k. Return the maximum amount of coins you can obtain by collecting k consecutive bags.

Input & Output

Example 1 — Basic Case

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

› Output: 40

💡 Note: The best 4 consecutive bags are positions 1-4, each containing 10 coins: 10 + 10 + 10 + 10 = 40 coins

Example 2 — Single Segment

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

› Output: 10

💡 Note: Any 2 consecutive bags within the segment give 5 + 5 = 10 coins

Example 3 — Cross Multiple Segments

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

› Output: 4

💡 Note: Best window spans positions 3-5: bag 3 has 0 coins (no segment covers it), bag 4 has 3 coins, bag 5 has 3 coins = 6 total

Constraints

1 ≤ coins.length ≤ 10⁵
1 ≤ l_i ≤ r_i ≤ 10⁵
1 ≤ c_i ≤ 1000
1 ≤ k ≤ 2 × 10⁵
The segments are non-overlapping

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to use coordinate compression to convert the sparse coordinate system into a dense array, then apply sliding window technique. The optimal approach sorts critical points, builds a compressed representation, and uses sliding window to find the maximum sum in O(n log n + m) time where m is the compressed coordinate range.

Common Approaches

✓ Binary Search Answer

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

Brute Force - Check All Possible Windows

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

For each possible starting position, iterate through k consecutive bags and sum up the coins. Since coordinates can be very large, we need to consider only relevant positions around the given segments.

Coordinate Compression + Sliding Window

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

Convert sparse coordinate system to a dense array by collecting all critical points (segment boundaries). Then use prefix sums and sliding window to efficiently find the maximum sum of k consecutive elements.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

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