Largest Sum of Averages

Largest Sum of Averages - Problem

You are given an integer array nums and an integer k. You can partition the array into at most k non-empty adjacent subarrays. The score of a partition is the sum of the averages of each subarray.

Note that the partition must use every integer in nums, and that the score is not necessarily an integer. Return the maximum score you can achieve of all the possible partitions. Answers within 10^-6 of the actual answer will be accepted.

Input & Output

Example 1 — Basic Partitioning

$ Input: nums = [9,1,2,3], k = 3

› Output: 13.5

💡 Note: Best partition is [9], [1,2], [3] with averages 9 + 1.5 + 3 = 13.5.

Example 2 — Single Partition

$ Input: nums = [1,2,3,4,5,6,7], k = 4

› Output: 20.83333

💡 Note: With k=4 partitions allowed, we can split into groups like [1],[2,3],[4,5],[6,7] giving averages 1 + 2.5 + 4.5 + 6.5 = 14.5, or try other combinations to maximize the sum of averages.

Example 3 — No Partitioning Needed

$ Input: nums = [4,1,7,9], k = 1

› Output: 5.25

💡 Note: With k=1, we must use the entire array as one partition: [4,1,7,9] with average (4+1+7+9)/4 = 21/4 = 5.25.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ k ≤ nums.length
0 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that we want to maximize the sum of averages by creating partitions strategically. Generally, smaller partitions with higher values will contribute more to the total score. The optimal approach uses dynamic programming to consider all possible partitioning strategies. Time: O(n²k), Space: O(nk)

Common Approaches

✓ Optimized

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

2D Dynamic Programming

⏱️ Time: O(n²k) Space: O(nk)

Build a 2D DP table where dp[i][j] represents the maximum score for nums[0:i] using at most j partitions.

Memoization (Top-Down DP)

⏱️ Time: O(n²k) Space: O(nk)

Same as brute force but store results of subproblems in a memo table to avoid recalculating the same (start, k) combinations.

Recursive Brute Force

⏱️ Time: O(2^n) Space: O(n)

For each position, try making a cut or not, exploring all possible ways to partition the array into at most k groups.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_WORDS 100
#define MAX_LEN 1000

int getCommonPrefixLength(char words[][MAX_LEN], int count) {
    if (count == 0) return 0;
    
    int minLen = strlen(words[0]);
    for (int i = 1; i < count; i++) {
        int len = strlen(words[i]);
        if (len < minLen) minLen = len;
    }
    
    int prefixLen = 0;
    for (int i = 0; i < minLen; i++) {
        char ch = words[0][i];
        int allMatch = 1;
        for (int j = 1; j < count; j++) {
            if (words[j][i] != ch) {
                allMatch = 0;
                break;
            }
        }
        if (allMatch) {
            prefixLen++;
        } else {
            break;
        }
    }
    
    return prefixLen;
}

void getCombinations(char remaining[][MAX_LEN], int n, int k, int start, char current[][MAX_LEN], int currentSize, int* maxPrefixLen) {
    if (currentSize == k) {
        int prefixLen = getCommonPrefixLength(current, k);
        if (prefixLen > *maxPrefixLen) {
            *maxPrefixLen = prefixLen;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        strcpy(current[currentSize], remaining[i]);
        getCombinations(remaining, n, k, i + 1, current, currentSize + 1, maxPrefixLen);
    }
}

int* solution(char words[][MAX_LEN], int wordsSize, int k, int* returnSize) {
    *returnSize = wordsSize;
    int* answer = (int*)malloc(wordsSize * sizeof(int));
    
    for (int i = 0; i < wordsSize; i++) {
        // Create array without words[i]
        char remaining[MAX_WORDS][MAX_LEN];
        int remainingSize = 0;
        
        for (int j = 0; j < wordsSize; j++) {
            if (j != i) {
                strcpy(remaining[remainingSize], words[j]);
                remainingSize++;
            }
        }
        
        // If not enough strings left
        if (remainingSize < k) {
            answer[i] = 0;
            continue;
        }
        
        int maxPrefixLen = 0;
        char current[MAX_WORDS][MAX_LEN];
        
        // Check all combinations of k strings
        getCombinations(remaining, remainingSize, k, 0, current, 0, &maxPrefixLen);
        
        answer[i] = maxPrefixLen;
    }
    
    return answer;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array more carefully
    char words[MAX_WORDS][MAX_LEN];
    int wordsSize = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++; // Find opening bracket
    if (*ptr) ptr++; // Skip '['
    
    while (*ptr && *ptr != ']' && wordsSize < MAX_WORDS) {
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '"')) ptr++;
        if (*ptr && *ptr != ']') {
            char* start = ptr;
            while (*ptr && *ptr != '"' && *ptr != ',' && *ptr != ']') ptr++;
            int len = ptr - start;
            if (len > 0 && len < MAX_LEN) {
                strncpy(words[wordsSize], start, len);
                words[wordsSize][len] = '\0';
                wordsSize++;
            }
            if (*ptr == '"') {
                ptr++;
                while (*ptr && *ptr != '"') ptr++;
                if (*ptr == '"') ptr++;
            }
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(words, wordsSize, k, &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

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

35.0K Views

Medium Frequency

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