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

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

✓ Brute Force (Try All Paths)

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

For each possible number of steps left (0 to k), try every possible number of steps right with remaining steps, considering both orders (left-first and right-first).

Sliding Window with Binary Search (Optimal)

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

The key insight is that optimal movement always follows one of two patterns: go left first then right, or go right first then left. We can use sliding window to efficiently explore all valid combinations.

Two Pointers with Prefix Sums

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

Create prefix sums for quick range queries, then use two pointers to find the optimal combination of left and right movements for each possible strategy.

Brute Force (Try All Paths) — Algorithm Steps

For each leftSteps from 0 to k:
Calculate remaining steps for right direction
Try both orders: left-first-then-right and right-first-then-left
For each order, simulate the movement and count fruits
Track the maximum fruits collected

Visualization

Tap to expand

Step-by-Step Walkthrough

Try leftSteps=0

Go right only, check all reachable positions

Try leftSteps=1

Go 1 left, then remaining right, check coverage

Continue pattern

Systematically try all left/right combinations

Code -

solution.c — C

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

int maxFruitsHarvested(int fruits[][2], int fruitsSize, int startPos, int k) {
    int max_fruits = 0;
    
    // Try different strategies
    for (int left_steps = 0; left_steps <= k; left_steps++) {
        int remaining_steps = k - left_steps;
        int fruits_collected = 0;
        
        // Strategy 1: Go left first, then right
        if (left_steps == 0) {
            // Only go right
            int right_bound = startPos + remaining_steps;
            for (int i = 0; i < fruitsSize; i++) {
                int pos = fruits[i][0];
                int amount = fruits[i][1];
                if (startPos <= pos && pos <= right_bound) {
                    fruits_collected += amount;
                }
            }
        } else if (remaining_steps < left_steps) {
            // Not enough steps to return and go right
            int left_bound = startPos - left_steps;
            for (int i = 0; i < fruitsSize; i++) {
                int pos = fruits[i][0];
                int amount = fruits[i][1];
                if (left_bound <= pos && pos <= startPos) {
                    fruits_collected += amount;
                }
            }
        } else {
            // Go left, return, then go right
            int right_steps = remaining_steps - left_steps;
            int left_bound = startPos - left_steps;
            int right_bound = startPos + right_steps;
            for (int i = 0; i < fruitsSize; i++) {
                int pos = fruits[i][0];
                int amount = fruits[i][1];
                if (left_bound <= pos && pos <= right_bound) {
                    fruits_collected += amount;
                }
            }
        }
        
        if (fruits_collected > max_fruits) {
            max_fruits = fruits_collected;
        }
    }
    
    // Try right first, then left
    for (int right_steps = 0; right_steps <= k; right_steps++) {
        int remaining_steps = k - right_steps;
        int fruits_collected = 0;
        
        if (right_steps == 0) {
            // Only go left
            int left_bound = startPos - remaining_steps;
            for (int i = 0; i < fruitsSize; i++) {
                int pos = fruits[i][0];
                int amount = fruits[i][1];
                if (left_bound <= pos && pos <= startPos) {
                    fruits_collected += amount;
                }
            }
        } else if (remaining_steps < right_steps) {
            // Not enough steps to return and go left
            int right_bound = startPos + right_steps;
            for (int i = 0; i < fruitsSize; i++) {
                int pos = fruits[i][0];
                int amount = fruits[i][1];
                if (startPos <= pos && pos <= right_bound) {
                    fruits_collected += amount;
                }
            }
        } else {
            // Go right, return, then go left
            int left_steps = remaining_steps - right_steps;
            int left_bound = startPos - left_steps;
            int right_bound = startPos + right_steps;
            for (int i = 0; i < fruitsSize; i++) {
                int pos = fruits[i][0];
                int amount = fruits[i][1];
                if (left_bound <= pos && pos <= right_bound) {
                    fruits_collected += amount;
                }
            }
        }
        
        if (fruits_collected > max_fruits) {
            max_fruits = fruits_collected;
        }
    }
    
    return max_fruits;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array [[a,b],[c,d],...]
    static int fruits[1000][2];
    int fruitsSize = 0;
    
    char *ptr = line;
    while (*ptr && *ptr != '[') ptr++; // find first '['
    ptr++; // skip outer '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // skip inner '['
            char *end;
            fruits[fruitsSize][0] = strtol(ptr, &end, 10);
            ptr = end;
            while (*ptr == ',' || *ptr == ' ') ptr++;
            fruits[fruitsSize][1] = strtol(ptr, &end, 10);
            ptr = end;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++; // skip inner ']'
            fruitsSize++;
        } else {
            ptr++;
        }
    }
    
    int startPos, k;
    scanf("%d\n%d", &startPos, &k);
    
    int result = maxFruitsHarvested(fruits, fruitsSize, startPos, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k² × n)

For each of k² combinations of left/right steps, we scan through fruit positions

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for tracking positions and sums

✓ Linear 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

Maximum Fruits Harvested After at Most K Steps - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler