Minimum Number of Coins for Fruits II - Practice Coding Problems

Minimum Number of Coins for Fruits II - Problem

Imagine you're shopping at an exotic fruit market where the vendor has an incredible offer! Each fruit comes with a special deal: when you buy the i-th fruit for prices[i] coins, you get the next i fruits completely free!

You're given a 1-indexed array prices where prices[i] represents the cost of the i-th fruit. Here's the twist: even if you can take a fruit for free, you can still choose to purchase it to unlock a new offer for subsequent fruits.

Goal: Find the minimum number of coins needed to acquire all fruits from the market.

Example: If prices = [3, 1, 2], buying fruit 1 for 3 coins gives you fruits 2 and 3 for free, costing only 3 coins total. Alternatively, buying fruit 2 for 1 coin gives you fruit 3 for free, then you'd need 3 coins for fruit 1, totaling 4 coins. The optimal choice is 3 coins!

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We can buy fruit 2 for 1 coin (get fruit 3 free), then buy fruit 1 for 3 coins. Total = 4 coins. Alternatively, buying fruit 1 first for 3 coins gets fruits 2 and 3 free, but costs more initially.

example_2.py — Single Fruit

$ Input: prices = [1]

› Output: 1

💡 Note: Only one fruit, must buy it for 1 coin.

example_3.py — Optimal Strategy

$ Input: prices = [26, 18, 6, 12, 49, 7, 45, 45]

› Output: 39

💡 Note: Optimal strategy involves buying certain fruits to maximize the free fruit coverage while minimizing total cost.

Visualization

Tap to expand

Understanding the Visualization

Analyze the Deals

Each fruit i offers next i fruits free when purchased

Work Backwards

Start from the end and determine optimal strategy for each position

Maintain Best Options

Use deque to track the cheapest ways to cover remaining fruits

Make Optimal Choice

At each fruit, choose between buying it or using a previous deal

Key Takeaway

🎯 Key Insight: The monotonic deque optimization allows us to efficiently find the minimum cost option among all valid previous purchases, reducing the time complexity from O(n²) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once, making it linear

✓ Linear Growth

Space Complexity

O(n)

DP array of size n plus deque storing at most n elements

⚡ Linearithmic Space

Constraints

1 ≤ prices.length ≤ 10⁵
1 ≤ prices[i] ≤ 10⁹
The array is 1-indexed in the problem description but 0-indexed in implementation

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses dynamic programming with a monotonic deque to achieve O(n) time complexity. We work backwards, maintaining the minimum cost to acquire all fruits from each position onwards, while using the deque to efficiently track the best purchase options within the valid range for each fruit.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Monotonic Deque	O(n)	O(n)	Optimal DP solution using deque to maintain minimum costs efficiently
Brute Force Recursive (Exponential)	O(2^n)	O(n)	Try all possible purchase combinations recursively

Dynamic Programming with Monotonic Deque — Algorithm Steps

Create DP array where dp[i] = min cost to get fruits from i to end
Work backwards from the last fruit
For each position, use deque to track minimum costs from valid purchase positions
A purchase at position j covers fruits j+1 to j+j, so it's valid for position i if i <= j+j
Maintain deque in increasing order of costs for efficient minimum queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Create DP array, work backwards from last fruit

Maintain Deque

Deque stores indices of positions with increasing DP values

Update Range

Remove positions outside current fruit's buying range

Calculate Minimum

Choose between buying current fruit or using deque minimum

Code -

solution.c — C

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

#define MIN(a,b) ((a) < (b) ? (a) : (b))

int minimumCoins(int* prices, int n) {
    int* dp = (int*)calloc(n + 1, sizeof(int));
    int* dq = (int*)malloc(n * sizeof(int));
    int front = 0, back = 0;
    
    for (int i = n - 1; i >= 0; i--) {
        while (back > front && dq[front] >= i + i + 2) {
            front++;
        }
        
        if (i == n - 1) {
            dp[i] = prices[i];
        } else {
            if (back > front) {
                dp[i] = MIN(prices[i] + dp[MIN(i + i + 2, n)], dp[dq[front]]);
            } else {
                dp[i] = prices[i] + dp[MIN(i + i + 2, n)];
            }
        }
        
        while (back > front && dp[dq[back - 1]] >= dp[i]) {
            back--;
        }
        dq[back++] = i;
    }
    
    int result = dp[0];
    free(dp);
    free(dq);
    return result;
}

int main() {
    int prices[] = {3, 1, 2};
    int n = 3;
    printf("%d\n", minimumCoins(prices, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once, making it linear

✓ Linear Growth

Space Complexity

O(n)

DP array of size n plus deque storing at most n elements

⚡ Linearithmic Space

Constraints

1 ≤ prices.length ≤ 10⁵
1 ≤ prices[i] ≤ 10⁹
The array is 1-indexed in the problem description but 0-indexed in implementation

43.5K Views

Medium Frequency

~35 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Monotonic Deque — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler