Maximum Fruits Harvested After at Most K Steps

Maximum Fruits Harvested After at Most K Steps - Problem

Imagine you're a fruit collector on an infinite horizontal line with fruit trees scattered at various positions. You start at a specific position and have a limited number of steps to collect as many fruits as possible!

You're given:
• fruits[i] = [position, amount] - fruit locations and quantities (sorted by position)
• startPos - your starting position
• k - maximum steps you can take

Goal: Maximize the total fruits collected within k steps. You can move left or right, and each unit of movement costs 1 step. When you reach a position with fruits, you automatically harvest all of them.

Key Challenge: Should you go left first then right? Right first then left? Or stay in one direction? The optimal strategy isn't always obvious!

Input & Output

example_1.py — Basic case

$ Input: fruits = [[2,8],[6,3],[8,6]], startPos = 5, k = 4

› Output: 9

💡 Note: Start at position 5 with 4 steps. Go right to position 6 (1 step) and collect 3 fruits, then go to position 8 (2 more steps) and collect 6 fruits. Total: 3 + 6 = 9 fruits using 3 steps.

example_2.py — Left and right movement

$ Input: fruits = [[0,9],[4,1],[5,7],[6,2],[7,4],[10,9]], startPos = 5, k = 4

› Output: 14

💡 Note: Start at position 5. Go left to position 4 (1 step) and collect 1 fruit, then return to start (1 step) and go right to positions 6 and 7 (2 steps) collecting 2 + 4 = 6 fruits. Also collect 7 fruits at start position. Total: 1 + 7 + 2 + 4 = 14 fruits.

example_3.py — Edge case with no fruits reachable

$ Input: fruits = [[0,3],[6,4],[8,5]], startPos = 3, k = 2

› Output: 0

💡 Note: Start at position 3 with only 2 steps. The nearest fruits are at positions 0 and 6, both requiring at least 3 steps to reach, so no fruits can be collected.

Constraints

1 ≤ fruits.length ≤ 10⁵
fruits[i].length = 2
0 ≤ startPos, position_i ≤ 2 × 10⁸
position_i-1 < position_i (sorted by position)
1 ≤ amount_i ≤ 10⁴
0 ≤ k ≤ 2 × 10⁵
Large coordinate space but sparse fruit distribution

Visualization

Tap to expand

Understanding the Visualization

Analyze Patterns

Recognize that optimal paths use left-first or right-first strategies

Calculate Costs

Account for return trip costs when switching directions

Find Ranges

Use binary search to efficiently find fruit positions in reachable range

Sum Efficiently

Use prefix sums for O(1) range sum calculations

Key Takeaway

🎯 Key Insight: The optimal solution recognizes that you only need to consider two movement patterns and uses efficient data structures to quickly evaluate all possibilities within the step budget.

Asked in

G Google 34 a Amazon 28 ⊞ Microsoft 19 f Meta 12

The optimal approach uses sliding window with binary search to efficiently explore movement patterns. Key insight: the optimal strategy always follows one of two patterns - go left first then right, or go right first then left. We enumerate all possible left distances and use prefix sums with binary search to quickly calculate fruits in reachable ranges, achieving O(k log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Prefix Sums	O(k log n)	O(n)	Use two pointers to efficiently explore left and right boundaries
Brute Force (Try All Paths)	O(k² × n)	O(1)	Try every possible combination of left and right movements
Sliding Window with Binary Search (Optimal)	O(k log n)	O(n)	Use sliding window technique with binary search for optimal fruit collection

Two Pointers with Prefix Sums — Algorithm Steps

Build prefix sums array for quick range sum queries
For each possible left distance (0 to k):
Calculate maximum right distance with remaining steps
Consider both movement orders: left-first and right-first
Use binary search to find fruit ranges efficiently
Track maximum fruits across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Build prefix sums

Create cumulative sum array for O(1) range queries

Try left distances

For each left distance, calculate optimal right coverage

Binary search bounds

Use binary search to find fruit positions in reachable range

Code -

solution.c — C

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

int binarySearch(int* arr, int n, int target, int findUpper) {
    int left = 0, right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (findUpper ? arr[mid] <= target : arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int maxFruitsHarvested(int** fruits, int fruitsSize, int startPos, int k) {
    if (fruitsSize == 0) return 0;
    
    int* positions = (int*)malloc(fruitsSize * sizeof(int));
    int* prefix = (int*)calloc(fruitsSize + 1, sizeof(int));
    
    // Extract positions and build prefix sums
    for (int i = 0; i < fruitsSize; i++) {
        positions[i] = fruits[i][0];
        prefix[i + 1] = prefix[i] + fruits[i][1];
    }
    
    int maxFruits = 0;
    
    // Try all combinations of left and right distances
    for (int leftDist = 0; leftDist <= k; leftDist++) {
        int rightDist = k - leftDist;
        
        // Case 1: Go left first, then right
        if (leftDist * 2 + rightDist <= k) {
            int leftBound = startPos - leftDist;
            int rightBound = startPos + rightDist;
            
            int leftIdx = binarySearch(positions, fruitsSize, leftBound, 0);
            int rightIdx = binarySearch(positions, fruitsSize, rightBound, 1) - 1;
            
            if (leftIdx <= rightIdx) {
                int fruits = prefix[rightIdx + 1] - prefix[leftIdx];
                if (fruits > maxFruits) {
                    maxFruits = fruits;
                }
            }
        }
        
        // Case 2: Go right first, then left
        if (rightDist * 2 + leftDist <= k) {
            int leftBound = startPos - leftDist;
            int rightBound = startPos + rightDist;
            
            int leftIdx = binarySearch(positions, fruitsSize, leftBound, 0);
            int rightIdx = binarySearch(positions, fruitsSize, rightBound, 1) - 1;
            
            if (leftIdx <= rightIdx) {
                int fruits = prefix[rightIdx + 1] - prefix[leftIdx];
                if (fruits > maxFruits) {
                    maxFruits = fruits;
                }
            }
        }
    }
    
    free(positions);
    free(prefix);
    return maxFruits;
}

Time & Space Complexity

Time Complexity

⏱️

O(k log n)

For each of k possible left distances, we do binary search (log n) to find ranges

⚡ Linearithmic

Space Complexity

O(n)

Extra space for prefix sums array

⚡ Linearithmic Space

43.6K Views

Medium-High Frequency

~25 min Avg. Time

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

Two Pointers with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler