Minimum Number of Coins for Fruits - Problem

You are given a 0-indexed integer array prices where prices[i] denotes the number of coins needed to purchase the (i + 1)th fruit.

The fruit market has the following reward for each fruit:

If you purchase the (i + 1)th fruit at prices[i] coins, you can get any number of the next i fruits for free.

Note: Even if you can take fruit j for free, you can still purchase it for prices[j - 1] coins to receive its reward.

Return the minimum number of coins needed to acquire all the fruits.

Input & Output

Example 1 — Basic Case

$ Input: prices = [3,1,2]

› Output: 4

💡 Note: Buy fruit 1 (cost 3, get fruit 2 free), then buy fruit 3 (cost 2). Total = 3 + 1 = 4. Alternatively: buy fruit 2 (cost 1, no free fruits), buy fruit 3 (cost 2, no free fruits), buy fruit 1 (cost 3, get next 1 fruit free but already have all). Total = 1 + 2 + 0 = 3. Wait, let me recalculate: Buy fruit 2 (cost 1), buy fruit 1 (cost 3, get next 1 fruit free which covers fruit 2 retroactively? No). Actually: Buy fruit 1 (cost 3, get fruit 2 free), buy fruit 3 (cost 2). Total = 5. Or buy fruit 2 (cost 1), buy fruit 3 (cost 2, get next 2 fruits free but there aren't any). Total cost = 1 + 2 = 3. But we still need fruit 1, so buy it for 3. Total = 6. Actually optimal: buy fruit 2 (index 1, cost 1), buy fruit 1 (index 0, cost 3, get next 0 fruits free - none). Total = 4.

Example 2 — Single Fruit

$ Input: prices = [1]

› Output: 1

💡 Note: Only one fruit to buy, costs 1 coin. Total = 1.

Example 3 — Two Fruits

$ Input: prices = [1,10]

› Output: 2

💡 Note: Buy fruit 1 (cost 1, get next 1 fruit free), so fruit 2 is free. Total = 1. Wait, that's wrong indexing. Buy fruit at index 0 (cost 1, get next 0 fruits free - none), then buy fruit at index 1 (cost 10). Total = 11. OR buy fruit at index 1 (cost 10, get next 1 fruit free, but there are no more fruits). So we still need fruit at index 0, costing 1. Total = 11. Actually optimal is: buy fruit 1 (index 0) for cost 1, buy fruit 2 (index 1) for cost 10. But wait, if we buy fruit 2 first (cost 10, get next 1 fruit free), we can't get fruit 1 free because it's before. So buy fruit 1 (cost 1, get 0 next fruits free), then buy fruit 2 (cost 10). Total = 11. But there might be a better way: we must buy fruit 1 for 1, and fruit 2 for 10, so minimum is 11. Hmm, let me reconsider the problem... Actually, I think the answer should be 2 if we can somehow get fruit 2 cheaper.

Constraints

1 ≤ prices.length ≤ 1000
1 ≤ prices[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that buying fruit i gives you the next i fruits for free, creating overlapping choices. Best approach uses dynamic programming with monotonic deque for O(n) time complexity by efficiently tracking minimum costs in sliding windows. Time: O(n), Space: O(n)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Work backwards from the end, computing minimum cost for each position. For each fruit, consider all possible previous purchases that could provide it for free.

Brute Force Recursion

⏱️ Time: O(2ⁿ) Space: O(n)

For each fruit, decide whether to buy it (and get free fruits) or get it for free from a previous purchase. Recursively explore all possibilities.

Memoization (Top-Down DP)

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

Same recursive approach but store results of subproblems to avoid redundant calculations. Use a memoization table indexed by position and free_until range.

Optimized DP with Deque

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

Process fruits from right to left using a deque to maintain minimum costs in the range of fruits that can be obtained for free from each purchase.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Initialize DP array
Step 2: Process fruits from right to left
Step 3: For each position, check all ways to get it
Step 4: Return minimum cost for position 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[n] = 0, others = infinity

Fill Backwards

For each position, find minimum cost

Final Answer

dp[0] contains minimum cost

Code -

solution.c — C

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

#define MAXN 1005
#define MEMO_SIZE 2000000

static int prices[MAXN];
static int n;
static int memo_keys[MEMO_SIZE][2];
static int memo_values[MEMO_SIZE];
static int memo_count = 0;

int min_int(int a, int b) {
    return (a < b) ? a : b;
}

int max_int(int a, int b) {
    return (a > b) ? a : b;
}

int get_memo(int pos, int free_until) {
    for (int i = 0; i < memo_count; i++) {
        if (memo_keys[i][0] == pos && memo_keys[i][1] == free_until) {
            return memo_values[i];
        }
    }
    return -1;
}

void set_memo(int pos, int free_until, int value) {
    if (memo_count < MEMO_SIZE) {
        memo_keys[memo_count][0] = pos;
        memo_keys[memo_count][1] = free_until;
        memo_values[memo_count] = value;
        memo_count++;
    }
}

int solve(int pos, int free_until) {
    if (pos >= n) {
        return 0;
    }
    
    int cached = get_memo(pos, free_until);
    if (cached != -1) {
        return cached;
    }
    
    int result;
    
    // If this fruit is free from previous purchase
    if (pos <= free_until) {
        // Can either take it for free or buy it for rewards
        int take_free = solve(pos + 1, free_until);
        // When buying fruit at pos, we get next pos fruits free
        int buy_anyway = prices[pos] + solve(pos + 1, max_int(free_until, pos + pos));
        result = min_int(take_free, buy_anyway);
    } else {
        // Must buy this fruit - get next pos fruits free
        result = prices[pos] + solve(pos + 1, pos + pos);
    }
    
    set_memo(pos, free_until, result);
    return result;
}

int solution() {
    memo_count = 0;
    return solve(0, -1);
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) return 1;
    
    n = 0;
    char* p = line;
    
    // Find opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\n') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        char* endp;
        long val = strtol(p, &endp, 10);
        if (endp != p) {
            prices[n++] = (int)val;
            p = endp;
        } else {
            break;
        }
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each position, check all previous positions that could cover it

✓ Linear Growth

Space Complexity

O(n)

DP array of size n

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

428 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

Minimum Number of Coins for Fruits - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler