Minimum Relative Loss After Buying Chocolates

Minimum Relative Loss After Buying Chocolates - Problem

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

Alice and Bob went to buy some chocolates. For each query, they follow these payment terms:

If the price of a chocolate is less than or equal to ki, Bob pays for it entirely
Otherwise, Bob pays ki of it, and Alice pays the rest

Bob wants to select exactly mi chocolates such that his relative loss is minimized. The relative loss is defined as bi - ai, where ai is the total amount Alice paid and bi is the total amount Bob paid.

Return an integer array ans where ans[i] is Bob's minimum relative loss possible for queries[i].

Input & Output

Example 1 — Basic Case

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

› Output: [3]

💡 Note: For k=5, m=2: Bob pays min(price,5) for each chocolate. Selecting chocolates with prices 2 and 9: Bob pays 2+5=7, Alice pays 0+4=4, relative loss = 7-4 = 3.

Example 2 — Multiple Queries

$ Input: prices = [1,4,8,2], queries = [[3,1],[6,2]]

› Output: [1,0]

💡 Note: Query 1 (k=3,m=1): Contributions are [1,4,2*3-8=-2,2]=[1,4,-2,2]. Best choice is price=8 with contribution=-2, so relative loss=1. Query 2 (k=6,m=2): Contributions are [1,4,4,2]. Best choices give contributions 1+2=3, so relative loss=0.

Example 3 — Large k Value

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

› Output: [3]

💡 Note: With k=10 (larger than all prices), Bob always pays full price. Best selection: prices 1,2. Bob pays 1+2=3, Alice pays 0, relative loss = 3-0 = 3.

Constraints

1 ≤ prices.length ≤ 10⁵
1 ≤ prices[i] ≤ 10⁹
1 ≤ queries.length ≤ 10⁵
1 ≤ k_i, m_i ≤ 10⁹
m_i ≤ prices.length

Visualization

Tap to expand

Asked in

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

The key insight is to calculate each chocolate's contribution to relative loss: for price ≤ k, contribution is price; for price > k, contribution is 2k - price. Sort these contributions and select the m smallest. Best approach is the greedy selection after sorting. Time: O(q × n log n), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(C(n,m) * q) Space: O(m)

For each query, generate all combinations of mi chocolates from the prices array. Calculate Bob's payment, Alice's payment, and relative loss for each combination. Return the minimum relative loss.

Optimized with Prefix Sums

⏱️ Time: O(n log n + q log n) Space: O(n)

Sort prices once at the beginning. For each query, use binary search to partition chocolates based on the threshold k, then use prefix sums to quickly calculate the minimum relative loss for any selection of m chocolates.

Sort and Greedy Selection

⏱️ Time: O(q * n log n) Space: O(n)

Sort the prices array first. For each query, calculate the relative loss contribution of each chocolate, then greedily select the m chocolates with the smallest contributions.

Brute Force — Algorithm Steps

Step 1: Generate all combinations of mi chocolates
Step 2: Calculate payments for each combination
Step 3: Find minimum relative loss

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to select chocolates

Calculate Payments

For each combination, compute Bob and Alice payments

Find Minimum

Return the combination with minimum relative loss

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parseQueries(const char* str, int queries[][2], int* queryCount) {
    *queryCount = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        queries[*queryCount][0] = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        queries[*queryCount][1] = (int)strtol(p, (char**)&p, 10);
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        (*queryCount)++;
    }
}

void generateCombinations(int* prices, int n, int k, int start, int* current, int currentSize, int*** combinations, int* combCount, int* combSizes) {
    if (currentSize == k) {
        (*combinations)[*combCount] = (int*)malloc(k * sizeof(int));
        for (int i = 0; i < k; i++) {
            (*combinations)[*combCount][i] = current[i];
        }
        combSizes[*combCount] = k;
        (*combCount)++;
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = prices[i];
        generateCombinations(prices, n, k, i + 1, current, currentSize + 1, combinations, combCount, combSizes);
    }
}

int* solution(int* prices, int pricesSize, int queries[][2], int queriesSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int q = 0; q < queriesSize; q++) {
        int k = queries[q][0];
        int m = queries[q][1];
        int min_loss = INT_MAX;
        
        // Calculate total combinations C(n,m)
        int totalCombinations = 1;
        for (int i = 0; i < m; i++) {
            totalCombinations = totalCombinations * (pricesSize - i) / (i + 1);
        }
        
        int** combinations = (int**)malloc(totalCombinations * sizeof(int*));
        int* combSizes = (int*)malloc(totalCombinations * sizeof(int));
        int combCount = 0;
        int* current = (int*)malloc(m * sizeof(int));
        
        generateCombinations(prices, pricesSize, m, 0, current, 0, &combinations, &combCount, combSizes);
        
        for (int i = 0; i < combCount; i++) {
            int bob_payment = 0;
            int alice_payment = 0;
            
            for (int j = 0; j < combSizes[i]; j++) {
                int price = combinations[i][j];
                if (price <= k) {
                    bob_payment += price;
                } else {
                    bob_payment += k;
                    alice_payment += price - k;
                }
            }
            
            int relative_loss = bob_payment - alice_payment;
            if (relative_loss < min_loss) {
                min_loss = relative_loss;
            }
        }
        
        result[q] = min_loss;
        
        // Free memory
        for (int i = 0; i < combCount; i++) {
            free(combinations[i]);
        }
        free(combinations);
        free(combSizes);
        free(current);
    }
    
    return result;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int prices[100];
    int pricesSize;
    parseArray(line1, prices, &pricesSize);
    
    int queries[100][2];
    int queriesSize;
    parseQueries(line2, queries, &queriesSize);
    
    int returnSize;
    int* result = solution(prices, pricesSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,m) * q)

For each query, we generate C(n,m) combinations where n is prices length and m is chocolates to select

⚡ Linearithmic

Space Complexity

O(m)

Space to store current combination of chocolates

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler