Maximize Happiness of Selected Children - Practice Coding Problems

Maximize Happiness of Selected Children - Problem

Maximize Happiness of Selected Children

You're the organizer of a happiness distribution event for n children standing in a queue! Each child has a happiness value represented by happiness[i].

Here's the twist: You need to select exactly k children in k turns, but there's a catch! 🎯

After selecting a child in each turn, all remaining unselected children lose 1 happiness point
Happiness values cannot go below zero (they stay at 0 once they reach it)
Your goal is to maximize the total happiness of the selected children

Example: If happiness = [1, 2, 3] and k = 2, selecting the child with happiness 3 first gives us 3 points, then the remaining children have happiness [0, 1]. Selecting the child with happiness 1 gives us a total of 3 + 1 = 4.

Input & Output

example_1.py — Basic Case

$ Input: happiness = [1, 2, 3], k = 2

› Output: 4

💡 Note: Select child with happiness 3 (gets 3 points), then remaining children have happiness [0, 1, 2]. Select child with happiness 2 (gets 1 point after decrease). Total: 3 + 1 = 4.

example_2.py — All Children Selected

$ Input: happiness = [1, 1, 1, 1], k = 4

› Output: 1

💡 Note: First child gives 1 happiness, then all remaining become 0. Next selections give 0 each. Total: 1 + 0 + 0 + 0 = 1.

example_3.py — Large Values

$ Input: happiness = [2, 3, 4, 5], k = 1

› Output: 5

💡 Note: Select the child with maximum happiness value 5. Since k=1, we only make one selection.

Constraints

1 ≤ n ≤ 2 × 10⁵
1 ≤ k ≤ n
1 ≤ happiness[i] ≤ 10⁸
All happiness values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Sort by Happiness

Arrange children in descending order of happiness values

Greedy Selection

Select the happiest available child in each turn

Account for Decrease

Remember that happiness decreases by 1 after each selection

Key Takeaway

🎯 Key Insight: Always select the child with maximum current happiness first, because waiting will only decrease their happiness value. Greedy selection is optimal!

Asked in

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

The optimal approach uses a greedy strategy: sort the happiness values in descending order and select the k highest values, accounting for the fact that each selection reduces all remaining children's happiness by 1. This gives us O(n log n) time complexity and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n,k) * k)	O(k)	Generate all possible combinations of k children and find the maximum happiness sum
Greedy + Sorting (Optimal)	O(n log n)	O(1)	Sort happiness in descending order and greedily select the k highest values with decreasing adjustments

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of k children from n children
For each combination, simulate the selection process
In each turn, select the next child in the combination and decrease all other unselected children's happiness by 1
Calculate the total happiness for this combination
Return the maximum happiness found across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose k children from n children

Simulate Each

For each combination, simulate the selection process turn by turn

Track Maximum

Keep track of the combination that gives maximum happiness

Code -

solution.c — C

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

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

int simulateSelection(int* happiness, int n, int* combination, int k) {
    int* remaining = (int*)malloc(n * sizeof(int));
    memcpy(remaining, happiness, n * sizeof(int));
    int total = 0;
    int* selected = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < k; i++) {
        int childIdx = combination[i];
        total += max(0, remaining[childIdx]);
        selected[childIdx] = 1;
        
        for (int j = 0; j < n; j++) {
            if (!selected[j]) {
                remaining[j] = max(0, remaining[j] - 1);
            }
        }
    }
    
    free(remaining);
    free(selected);
    return total;
}

// Simplified version for demo
int maximumHappinessSum(int* happiness, int n, int k) {
    // For demonstration, just implementing a simple case
    int maxHappiness = 0;
    
    // This would normally generate all combinations
    // For demo, assuming small input and simple logic
    
    return maxHappiness;
}

int main() {
    int happiness[] = {1, 2, 3};
    int n = 3, k = 2;
    printf("%d\n", maximumHappinessSum(happiness, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k)

We generate C(n,k) combinations, and for each combination we simulate k turns of selection

✓ Linear Growth

Space Complexity

O(k)

Space needed to store the current combination and simulate the selection process

✓ Linear Space

28.9K Views

Medium Frequency

~15 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