Reducing Dishes

Reducing Dishes - Problem

A chef has collected data on the satisfaction level of his n dishes. Chef can cook any dish in 1 unit of time.

Like-time coefficient of a dish is defined as the time taken to cook that dish including previous dishes multiplied by its satisfaction level i.e. time[i] * satisfaction[i].

Return the maximum sum of like-time coefficient that the chef can obtain after preparing some amount of dishes.

Dishes can be prepared in any order and the chef can discard some dishes to get this maximum value.

Input & Output

Example 1 — Mixed Values

$ Input: satisfaction = [-1,0,3,1,2]

› Output: 25

💡 Note: After sorting: [-1,0,1,2,3]. Optimal selection is dishes with satisfaction [1,2,3] cooked in this order. Like-time coefficient: 1×1 + 2×2 + 3×3 = 14. But we can include all dishes: 1×(-1) + 2×0 + 3×1 + 4×2 + 5×3 = 20. Actually, using greedy: 25.

Example 2 — All Negative

$ Input: satisfaction = [-2,-3,-1]

› Output: 0

💡 Note: All satisfaction values are negative. Best strategy is to cook no dishes, resulting in sum = 0.

Example 3 — All Positive

$ Input: satisfaction = [4,3,2]

› Output: 20

💡 Note: All positive values. Sort to [2,3,4]. Cook in this order: 1×2 + 2×3 + 3×4 = 2 + 6 + 12 = 20.

Constraints

1 ≤ satisfaction.length ≤ 500
-1000 ≤ satisfaction[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to sort the satisfaction array and use a greedy approach: add dishes from highest satisfaction while the suffix sum remains positive. Each dish contributes its suffix sum to the total score. Best approach is greedy optimization. Time: O(n log n), Space: O(1)

Common Approaches

✓ Brute Force - All Subsets

⏱️ Time: O(n! × 2ⁿ) Space: O(n)

Generate all possible subsets of dishes, for each subset try all possible orderings, and calculate the like-time coefficient sum for each combination.

Greedy Optimization

⏱️ Time: O(n log n) Space: O(1)

Sort satisfaction values, then use a greedy approach: start from the highest satisfaction and keep adding dishes as long as they contribute positively to the total sum.

Sort and Try Starting Points

⏱️ Time: O(n²) Space: O(1)

Sort the satisfaction array in ascending order, then for each possible starting position, calculate the like-time coefficient by including all dishes from that position onwards.

Brute Force - All Subsets — Algorithm Steps

Generate all 2^n possible subsets
For each subset, try all n! possible orderings
Calculate coefficient sum for each combination
Return maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible subsets of dishes

Try Orderings

For each subset, try all possible cooking orders

Calculate Score

Compute like-time coefficient for each combination

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int calculateSum(int* satisfaction, int* subset, int subsetSize) {
    int sum = 0;
    for (int i = 0; i < subsetSize; i++) {
        sum += (i + 1) * satisfaction[subset[i]];
    }
    return sum;
}

void generatePermutations(int* satisfaction, int* subset, int subsetSize, int start, int* maxSum) {
    if (start == subsetSize) {
        int currentSum = calculateSum(satisfaction, subset, subsetSize);
        *maxSum = max(*maxSum, currentSum);
        return;
    }
    
    for (int i = start; i < subsetSize; i++) {
        swap(&subset[start], &subset[i]);
        generatePermutations(satisfaction, subset, subsetSize, start + 1, maxSum);
        swap(&subset[start], &subset[i]);
    }
}

int solution(int* satisfaction, int n) {
    int maxSum = 0;
    int subset[n];
    
    // Try all possible subsets
    for (int mask = 0; mask < (1 << n); mask++) {
        int subsetSize = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subset[subsetSize++] = i;
            }
        }
        
        if (subsetSize > 0) {
            generatePermutations(satisfaction, subset, subsetSize, 0, &maxSum);
        }
    }
    
    return maxSum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int satisfaction[500];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        satisfaction[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(satisfaction, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × 2ⁿ)

Generate 2^n subsets, each with up to n! permutations

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current subset and permutation

✓ Linear Space

28.0K Views

Medium Frequency

~15 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 - All Subsets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler