Minimum Relative Loss After Buying Chocolates

Minimum Relative Loss After Buying Chocolates - Problem

You are given an integer array prices representing chocolate prices and a 2D integer array queries where queries[i] = [ki, mi].

Alice and Bob are at a chocolate shop and have agreed on a payment strategy:

If a chocolate costs ≤ ki, Bob pays the full price
If a chocolate costs > ki, Bob pays ki and Alice pays the remainder

For each query, Bob wants to select exactly mi chocolates to minimize his relative loss, defined as bi - ai where bi is Bob's total payment and ai is Alice's total payment.

Return an array where the i-th element is Bob's minimum possible relative loss for query i.

Input & Output

example_1.py — Basic Case

$ Input: prices = [8, 15, 12, 6], queries = [[10, 2]]

› Output: [5]

💡 Note: For k=10, m=2: Bob wants to select 2 chocolates. For chocolate costing 8≤10, Bob pays 8, Alice pays 0. For chocolate costing 15>10, Bob pays 10, Alice pays 5. Best selection is chocolates costing 15 and 6: Bob pays 10+6=16, Alice pays 5+0=5, relative loss = 16-5 = 11. Wait, let me recalculate... Actually the optimal is chocolates 15 and 6 giving loss = (10+6) - (5+0) = 11. But we need to check all combinations systematically.

example_2.py — Multiple Queries

$ Input: prices = [5, 10, 15, 20], queries = [[12, 2], [8, 3]]

› Output: [2, 18]

💡 Note: Query 1: k=12, m=2. Best selection minimizes Bob's relative loss. Query 2: k=8, m=3. Bob has a lower limit, so more chocolates will require Alice's contribution.

example_3.py — Edge Case

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

› Output: [6]

💡 Note: All chocolates cost ≤ k=5, so Bob pays full price for all: 1+2+3=6, Alice pays 0, relative loss = 6-0 = 6.

Constraints

1 ≤ prices.length ≤ 10⁵
1 ≤ prices[i] ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
1 ≤ ki ≤ 10⁹
1 ≤ mi ≤ prices.length

Visualization

Tap to expand

Understanding the Visualization

Calculate Impact

For each chocolate, determine its contribution to Bob's relative loss

Rank Choices

Sort chocolates by their impact - prefer items where Alice pays more

Select Optimally

Choose the m chocolates with the best impact on relative loss

Key Takeaway

🎯 Key Insight: Transform the problem from finding combinations to ranking items by their contribution to relative loss. Expensive items (> k) actually help Bob because Alice pays more than he does!

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach is to realize that each chocolate contributes a fixed amount to Bob's relative loss. For chocolates costing ≤ k, Bob pays the full price (positive contribution). For expensive chocolates > k, Alice pays more than Bob (negative contribution = 2k - price). Sort chocolates by contribution and greedily select the m chocolates with the lowest contributions for O(q × n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(q * C(n, m))	O(m)	Generate all possible combinations of mi chocolates and calculate relative loss for each
Sorting + Greedy Selection	O(q * n log n)	O(n)	Sort chocolates by their contribution to relative loss and greedily select the best ones

Brute Force (Try All Combinations) — Algorithm Steps

For each query (ki, mi), generate all C(n, mi) combinations
For each combination, calculate Bob's and Alice's payments
If price ≤ ki: Bob pays price, Alice pays 0
If price > ki: Bob pays ki, Alice pays (price - ki)
Calculate relative loss = total_bob - total_alice
Return minimum relative loss across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to select m chocolates from n available

Calculate Payments

For each combination, determine Bob's and Alice's total payments

Find Minimum

Track the combination that gives Bob the lowest relative loss

Code -

solution.c — C

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

int calculateLoss(int* combination, int size, int k) {
    int bobTotal = 0, aliceTotal = 0;
    for (int i = 0; i < size; i++) {
        if (combination[i] <= k) {
            bobTotal += combination[i];
        } else {
            bobTotal += k;
            aliceTotal += combination[i] - k;
        }
    }
    return bobTotal - aliceTotal;
}

void generateCombinations(int* prices, int n, int m, int start, int* current, int currentSize, int* minLoss, int k) {
    if (currentSize == m) {
        int loss = calculateLoss(current, m, k);
        if (loss < *minLoss) {
            *minLoss = loss;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = prices[i];
        generateCombinations(prices, n, m, i + 1, current, currentSize + 1, minLoss, k);
    }
}

int* minimumRelativeLosses(int* prices, int pricesSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    int* result = (int*)malloc(queriesSize * sizeof(int));
    
    for (int i = 0; i < queriesSize; i++) {
        int k = queries[i][0];
        int m = queries[i][1];
        int minLoss = INT_MAX;
        
        int* current = (int*)malloc(m * sizeof(int));
        generateCombinations(prices, pricesSize, m, 0, current, 0, &minLoss, k);
        
        result[i] = minLoss;
        free(current);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * C(n, m))

For each of q queries, we check C(n, m) combinations where n is array length and m is chocolates to select

✓ Linear Growth

Space Complexity

O(m)

Space to store current combination and calculate payments

✓ Linear Space

26.2K Views

Medium Frequency

~35 min Avg. Time

847 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler