Maximize Happiness of Selected Children - Problem

You are given an array happiness of length n, and a positive integer k.

There are n children standing in a queue, where the i-th child has happiness value happiness[i]. You want to select k children from these n children in k turns.

In each turn, when you select a child, the happiness value of all the children that have not been selected till now decreases by 1. Note that the happiness value cannot become negative and gets decremented only if it is positive.

Return the maximum sum of the happiness values of the selected children you can achieve by selecting k children.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Select children with happiness 3 and 2. Child with happiness 3 contributes 3, child with happiness 2 (after 1 decay) contributes 1. Total: 3 + 1 = 4

Example 2 — Larger Array

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

› Output: 1

💡 Note: All children have same happiness. Pick any 2: first contributes 1, second contributes 0 (after 1 decay). Total: 1 + 0 = 1

Example 3 — High Happiness Values

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

› Output: 5

💡 Note: Select the child with maximum happiness 5. No decay affects the selected child. Total: 5

Constraints

1 ≤ n ≤ 2 × 10⁵
1 ≤ k ≤ n
1 ≤ happiness[i] ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32

The key insight is to use a greedy approach - always select the child with highest current happiness. The optimal solution sorts children by happiness and uses the mathematical formula max(0, happiness[i] - i) to calculate the final happiness without simulation. Time: O(n log n), Space: O(1)

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(C(n,k) × k) Space: O(k)

Try every possible way to select k children from n children. For each combination, simulate the selection process where happiness decreases by 1 after each pick.

Greedy - Always Pick Highest

⏱️ Time: O(n log n + k²) Space: O(n)

Sort children in descending order by happiness. In each turn, pick the child with highest current happiness value, then decrease all remaining children's happiness by 1.

Optimized - Mathematical Formula

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

Key insight: if we sort children by happiness descending and select the first k, the i-th selected child will have their happiness reduced by i turns (0-indexed). We can calculate this directly without simulation.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* happiness, int n, int k) {
    int* currentHappiness = (int*)malloc(n * sizeof(int));
    int* selected = (int*)calloc(n, sizeof(int));
    
    // Copy happiness array
    for (int i = 0; i < n; i++) {
        currentHappiness[i] = happiness[i];
    }
    
    int totalSum = 0;
    
    for (int turn = 0; turn < k; turn++) {
        // Find the child with maximum current happiness among unselected
        int maxHappiness = -1;
        int bestChild = -1;
        
        for (int i = 0; i < n; i++) {
            if (!selected[i] && currentHappiness[i] > maxHappiness) {
                maxHappiness = currentHappiness[i];
                bestChild = i;
            }
        }
        
        // Select this child
        selected[bestChild] = 1;
        if (currentHappiness[bestChild] > 0) {
            totalSum += currentHappiness[bestChild];
        }
        
        // Decrease happiness of all unselected children
        for (int i = 0; i < n; i++) {
            if (!selected[i]) {
                currentHappiness[i] = currentHappiness[i] - 1;
                if (currentHappiness[i] < 0) {
                    currentHappiness[i] = 0;
                }
            }
        }
    }
    
    free(currentHappiness);
    free(selected);
    return totalSum;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse happiness array
    int happiness[1000];
    int n = 0;
    char* p = input;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        happiness[n++] = (int)strtol(p, &p, 10);
    }
    
    // Read k
    fgets(input, sizeof(input), stdin);
    int k = atoi(input);
    
    int result = solution(happiness, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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