Minimum Number of Coins for Fruits - Practice Coding Problems

Minimum Number of Coins for Fruits - Problem

Welcome to the Magical Fruit Market! 🍎🍊🍌

You're at a special fruit market where each fruit has a unique pricing system. You are given a 0-indexed integer array prices where prices[i] represents the number of coins needed to purchase the (i + 1)th fruit.

Here's the magical twist: When you purchase the (i + 1)th fruit at prices[i] coins, you receive a special reward - you can get any number of the next i fruits for free!

Important notes:

Even if you can take a fruit for free, you can still choose to purchase it to receive its reward
The reward for fruit i+1 gives you free access to the next i fruits (not i+1 fruits)
You need to acquire all fruits in the market

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

Example: If prices = [3,1,2], buying fruit 1 (costs 3 coins) gives you 0 free fruits, buying fruit 2 (costs 1 coin) gives you 1 free fruit, and buying fruit 3 (costs 2 coins) gives you 2 free fruits.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Buy fruit 1 at cost 3 (no free fruits), buy fruit 2 at cost 1 (get 1 free fruit, so fruit 3 is free). Total cost = 3 + 1 = 4.

example_2.py — Strategic Purchase

$ Input: prices = [1,10,1,1]

› Output: 2

💡 Note: Buy fruit 1 at cost 1, then buy fruit 3 at cost 1 (this gives 2 free fruits, so fruit 4 is free). We can get fruit 2 for free from fruit 3's reward. Total cost = 1 + 1 = 2.

example_3.py — Single Fruit

$ Input: prices = [26]

› Output: 26

💡 Note: Only one fruit available, must buy it at cost 26. Total cost = 26.

Constraints

1 ≤ prices.length ≤ 1000
1 ≤ prices[i] ≤ 1000
Each fruit must be acquired exactly once
Free fruits from purchase i can be used for fruits (i+1) to (i+1)+i

Visualization

Tap to expand

Understanding the Visualization

Understand the Reward System

Each fruit i gives you (i-1) free fruits from the next ones. Plan strategically!

Use Dynamic Programming

For each position, calculate the minimum cost considering all ways to reach it

Optimize with Sliding Window

Use monotonic deque to efficiently find minimum cost in valid range

Make Optimal Decisions

At each step, choose between buying or getting fruit for free from previous purchases

Key Takeaway

🎯 Key Insight: Use dynamic programming with monotonic deque to efficiently track the minimum cost among all positions that can provide free fruits, achieving optimal O(n) time complexity.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses Dynamic Programming with Monotonic Deque to achieve O(n) time complexity. The key insight is to maintain a sliding window of minimum costs for positions that can provide free fruits to the current position. We use a monotonic deque to efficiently find the minimum cost in the valid range, avoiding the O(n²) complexity of checking all previous positions.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Monotonic Deque (Optimal)	O(n)	O(n)	Use sliding window minimum with deque for optimal performance
Dynamic Programming with Memoization	O(n²)	O(n²)	Optimize brute force by caching subproblem results
Recursive Brute Force	O(2^n)	O(n)	Try all possible ways to acquire fruits using recursion

Dynamic Programming with Monotonic Deque (Optimal) — Algorithm Steps

Use DP where dp[i] = minimum cost to get all fruits from 0 to i
For each position i, find all previous positions j where buying j gives free fruit i
Use monotonic deque to maintain minimum dp[j] in the valid range
Update dp[i] = min(deque_min + prices[i], dp[i-1] if can get free)
Maintain deque by removing out-of-range elements and keeping monotonic property

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[0] = prices[0], deque contains position 0

Slide window

Remove positions outside valid range for current fruit

Find minimum

Front of deque gives minimum cost in valid range

Update deque

Add current position while maintaining monotonic property

Code -

solution.c — C

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

int minimumCoins(int* prices, int n) {
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    int* dq = (int*)malloc(n * sizeof(int));
    int front = 0, back = -1;
    
    for (int i = 0; i <= n; i++) dp[i] = INT_MAX;
    dp[0] = prices[0];
    dq[++back] = 0;
    
    for (int i = 1; i < n; i++) {
        // Remove elements outside window
        while (front <= back && dq[front] < (i - 1) / 2) {
            front++;
        }
        
        // Can get current fruit for free
        if (front <= back) {
            if (dp[dq[front]] < dp[i]) {
                dp[i] = dp[dq[front]];
            }
        }
        
        // Consider buying current fruit
        if (dp[i - 1] + prices[i] < dp[i]) {
            dp[i] = dp[i - 1] + prices[i];
        }
        
        // Maintain monotonic property
        while (front <= back && dp[dq[back]] >= dp[i]) {
            back--;
        }
        dq[++back] = i;
    }
    
    int result = dp[n - 1];
    free(dp);
    free(dq);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int prices[100];
    int n = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        prices[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", minimumCoins(prices, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element enters and exits the deque at most once, linear scan

✓ Linear Growth

Space Complexity

O(n)

DP array and deque store at most n elements

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Dynamic Programming with Monotonic Deque (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler