Closest Dessert Cost

Closest Dessert Cost - Problem

You would like to make dessert and are preparing to buy the ingredients. You have n ice cream base flavors and m types of toppings to choose from. You must follow these rules when making your dessert:

There must be exactly one ice cream base.
You can add one or more types of topping or have no toppings at all.
There are at most two of each type of topping.

You are given three inputs:

baseCosts, an integer array of length n, where each baseCosts[i] represents the price of the ith ice cream base flavor.
toppingCosts, an integer array of length m, where each toppingCosts[i] is the price of one of the ith topping.
target, an integer representing your target price for dessert.

You want to make a dessert with a total cost as close to target as possible.

Return the closest possible cost of the dessert to target. If there are multiple, return the lower one.

Input & Output

Example 1 — Basic Case

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

› Output: 10

💡 Note: Consider base cost 7 with 1 topping of cost 3: 7 + 3 = 10, which exactly equals target 10

Example 2 — Multiple Closest

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

› Output: 17

💡 Note: Base 3 + 2×4 + 2×5 = 3 + 8 + 10 = 21 (distance 3), Base 2 + 2×4 + 1×5 = 2 + 8 + 5 = 15 (distance 3), and Base 3 + 2×4 + 1×5 = 17 (distance 1). The closest is 17.

Example 3 — Lower Cost Tie

$ Input: baseCosts = [3,10], toppingCosts = [2,5], target = 9

› Output: 8

💡 Note: Base 3 + 1×5 = 8 (distance 1), Base 10 + 0 toppings = 10 (distance 1). Both have same distance but 8 < 10, so return 8

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8

The key insight is to use backtracking to explore all possible dessert combinations: exactly one base + 0-2 of each topping. Best approach is memoized backtracking to avoid recalculating topping combinations. Time: O(n × 3^m), Space: O(3^m)

Common Approaches

✓ Brute Force with Backtracking

⏱️ Time: O(n × 3^m) Space: O(m)

For each ice cream base, use backtracking to explore all possible topping combinations (0, 1, or 2 of each topping). Keep track of the closest cost to target found so far.

Memoized Backtracking

⏱️ Time: O(n × 3^m) Space: O(3^m + m)

Use backtracking with memoization to cache results of topping combinations. Since the same topping combinations can be reached in different orders, we can avoid recalculating them.

Brute Force with Backtracking — Algorithm Steps

Step 1: Try each base flavor as starting point
Step 2: Use backtracking to try 0, 1, or 2 of each topping
Step 3: Track closest cost to target, preferring lower cost on ties

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Base

Select ice cream base as starting cost

Backtrack Toppings

Try 0, 1, or 2 of each topping recursively

Track Closest

Update closest cost to target found so far

Code -

solution.c — C

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

int closest_dist = INT_MAX;
int result = INT_MAX;

void backtrack(int* toppingCosts, int toppingSize, int index, int currentCost, int target) {
    // Update closest if current cost is closer to target
    int distance = abs(currentCost - target);
    if (distance < closest_dist || (distance == closest_dist && currentCost < result)) {
        closest_dist = distance;
        result = currentCost;
    }
    
    // If we've processed all toppings, return
    if (index >= toppingSize) {
        return;
    }
    
    // Try 0, 1, or 2 of current topping
    for (int count = 0; count < 3; count++) {
        backtrack(toppingCosts, toppingSize, index + 1, currentCost + count * toppingCosts[index], target);
    }
}

int solution(int* baseCosts, int baseSize, int* toppingCosts, int toppingSize, int target) {
    closest_dist = INT_MAX;
    result = INT_MAX;
    
    // Try each base
    for (int i = 0; i < baseSize; i++) {
        backtrack(toppingCosts, toppingSize, 0, baseCosts[i], target);
    }
    
    return result;
}

int main() {
    char line[1000];
    
    // Parse baseCosts
    fgets(line, sizeof(line), stdin);
    int baseCosts[50], baseSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        baseCosts[baseSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    // Parse toppingCosts
    fgets(line, sizeof(line), stdin);
    int toppingCosts[50], toppingSize = 0;
    token = strtok(line, "[],\n");
    while (token != NULL) {
        toppingCosts[toppingSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    // Parse target
    int target;
    scanf("%d", &target);
    
    int res = solution(baseCosts, baseSize, toppingCosts, toppingSize, target);
    printf("%d\n", res);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 3^m)

For each of n bases, we have 3 choices (0, 1, 2) for each of m toppings

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth is at most m (number of toppings)

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler