Closest Dessert Cost - Practice Coding Problems

Closest Dessert Cost - Problem

The Ice Cream Shop Challenge

You're at an artisanal ice cream shop planning to create the perfect dessert! The shop has n different ice cream base flavors and m types of delicious toppings to choose from.

Rules for creating your dessert:
🍦 You must choose exactly one ice cream base
🍓 You can add zero or more types of toppings
🎯 You can use at most two servings of each topping type

Given three inputs:
• baseCosts[] - prices of each ice cream base
• toppingCosts[] - prices of each topping type
• target - your ideal budget

Goal: Find the total cost that gets you as close as possible to your target budget. If multiple combinations tie, return the lower cost.

Input & Output

example_1.py — Basic Case

$ Input: baseCosts = [1,7], toppingCosts = [3,4], target = 10

› Output: 10

💡 Note: Consider all combinations: base 1 + toppings = [1, 1+3, 1+3+3, 1+4, 1+4+4, 1+3+4, 1+3+3+4, 1+3+4+4, 1+3+3+4+4] = [1, 4, 7, 5, 9, 8, 11, 12, 15]. Base 7 gives [7, 10, 13, 11, 15, 14, 17, 18, 21]. The closest to target 10 is 10.

example_2.py — Tie-Breaking

$ Input: baseCosts = [2,3], toppingCosts = [4,5,100], target = 18

› Output: 17

💡 Note: Multiple combinations can achieve difference of 1 from target 18: cost 17 (diff=1) and cost 19 (diff=1). We return 17 as it's the lower cost. One way to get 17: base 3 + two servings of topping 4 + one serving of topping 5 = 3 + 8 + 5 = 16, or base 2 + topping combinations.

example_3.py — Edge Case

$ Input: baseCosts = [10], toppingCosts = [1], target = 1

› Output: 10

💡 Note: With only one base costing 10 and target 1, the closest we can get is the base itself (10), giving a difference of 9. Adding toppings would only increase the cost further from target.

Constraints

n == baseCosts.length
m == toppingCosts.length
1 ≤ n, m ≤ 10
1 ≤ baseCosts[i], toppingCosts[i] ≤ 10⁴
1 ≤ target ≤ 10⁴

Visualization

Tap to expand

Understanding the Visualization

Choose Your Base

Start by selecting one ice cream base flavor - this is mandatory

Add First Topping

For the first topping type, decide: 0, 1, or 2 servings

Continue with Remaining

Repeat the decision for each remaining topping type

Calculate and Compare

Sum the total cost and see how close it is to your target budget

Key Takeaway

🎯 Key Insight: Use backtracking to systematically explore all possible dessert combinations while pruning branches that cannot lead to better solutions, making the search efficient and optimal.

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 Apple 3

The optimal approach uses backtracking with pruning to efficiently explore all possible dessert combinations. For each ice cream base, we recursively try 0, 1, or 2 servings of each topping type, pruning branches that cannot lead to better solutions. This reduces the search space significantly while guaranteeing the optimal result.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Pruning (Optimal)	O(n * 3^m)	O(m)	Use backtracking to explore combinations efficiently with early termination
Brute Force (Try All Combinations)	O(n * 3^m)	O(1)	Generate all possible dessert combinations and find the closest cost

Backtracking with Pruning (Optimal) — Algorithm Steps

For each ice cream base, start backtracking with that base cost
At each step, decide how many of current topping to use (0, 1, or 2)
Prune branches where current cost already exceeds our best difference
Use DFS to explore all remaining valid combinations
Update the closest cost whenever we find a better solution

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Base

Begin with ice cream base cost

Branch Toppings

Try 0, 1, 2 servings of each topping

Prune Early

Skip branches that can't improve solution

Track Best

Update closest cost found so far

Code -

solution.c — C

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

static int closestResult;

void backtrack(int* toppingCosts, int toppingSize, int index, int currentCost, int target) {
    // Update closest cost if current is better
    if (abs(currentCost - target) < abs(closestResult - target) ||
        (abs(currentCost - target) == abs(closestResult - target) && currentCost < closestResult)) {
        closestResult = currentCost;
    }
    
    // Base case: processed all toppings or exceeded reasonable cost
    if (index == toppingSize || currentCost >= target) {
        return;
    }
    
    // Try 0, 1, or 2 of current topping
    int toppingCost = toppingCosts[index];
    for (int count = 0; count < 3; count++) {
        int newCost = currentCost + count * toppingCost;
        if (newCost <= target + abs(closestResult - target)) {
            backtrack(toppingCosts, toppingSize, index + 1, newCost, target);
        }
    }
}

int closestCost(int* baseCosts, int baseSize, int* toppingCosts, int toppingSize, int target) {
    closestResult = INT_MAX;
    
    // Try each base and find best combination
    for (int i = 0; i < baseSize; i++) {
        closestResult = baseCosts[i]; // Initialize with base cost
        backtrack(toppingCosts, toppingSize, 0, baseCosts[i], target);
    }
    
    return closestResult;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 3^m)

In worst case same as brute force, but pruning makes it much faster in practice

✓ Linear Growth

Space Complexity

O(m)

Recursion depth is at most m (number of toppings)

✓ Linear Space

26.0K Views

Medium Frequency

~18 min Avg. Time

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

Backtracking with Pruning (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler