Partition Array for Maximum Sum - Practice Coding Problems

Partition Array for Maximum Sum - Problem

You are given an integer array arr and need to partition it strategically to maximize the sum. Here's the challenge: you can divide the array into contiguous subarrays where each subarray has at most k elements.

After partitioning, here's the key transformation: every element in each subarray becomes the maximum value of that subarray. Your goal is to find the partitioning strategy that produces the largest possible sum.

Example: If arr = [1, 15, 7, 9, 2] and k = 3, you could partition it as [1, 15, 7] + [9, 2]. The first subarray becomes [15, 15, 15] (sum = 45) and the second becomes [9, 9] (sum = 18), giving a total of 63.

This is a classic dynamic programming problem where you need to explore different partitioning strategies while respecting the constraint that each partition can contain at most k elements.

Input & Output

example_1.py — Basic Case

$ Input: arr = [1,15,7,9,2,5,10], k = 3

› Output: 84

💡 Note: Optimal partitioning: [15,15,15] + [9,9] + [10,10,10] = 45 + 18 + 30 = 84. We group [1,15,7], [9,2], and [5,10] to maximize the sum by replacing each element with the maximum in its group.

example_2.py — Small Array

$ Input: arr = [1,4,1,5,7,3,6,1,9,9,3], k = 4

› Output: 83

💡 Note: One optimal partitioning is [7,7,7,7] + [6,6] + [9,9,9,9]. By carefully choosing partition boundaries, we maximize the contribution of larger elements like 7 and 9.

example_3.py — Edge Case

$ Input: arr = [1], k = 1

› Output: 1

💡 Note: Single element array with k=1 means we can only have one partition of size 1, so the answer is just the element itself.

Constraints

1 ≤ arr.length ≤ 500
0 ≤ arr[i] ≤ 10⁹
1 ≤ k ≤ arr.length
Answer fits in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Identify dishes

Array elements are dishes with different prices

Create combos

Group consecutive dishes into combos of at most k dishes

Price combos

Each dish in a combo gets priced at the combo's highest price

Maximize revenue

Choose grouping strategy that maximizes total revenue

Key Takeaway

🎯 Key Insight: The optimal strategy groups array elements to maximize the impact of high-value elements, similar to how a restaurant creates combo meals to boost revenue by pricing all items at the premium level.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses dynamic programming with state dp[i] representing the maximum sum for the first i elements. For each position, we consider all valid partition endings (up to k elements back) and choose the one that maximizes the sum. The key insight is that we only need to track the maximum element in each potential partition, achieving O(n*k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n*k)	O(n)	Use memoization to avoid recalculating subproblems, achieving optimal efficiency
Brute Force (Recursive with All Partitions)	O(k^n)	O(n)	Try every possible way to partition the array recursively

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP array where dp[i] = maximum sum for first i elements
For each position i, consider all partitions ending at i-1 with length ≤ k
For each partition, find the maximum element and calculate contribution
Update dp[i] with the maximum sum found
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

dp[0] = 0 (empty array has sum 0)

Fill DP table

For each position i, consider all valid partition endings

Find maximum

Choose the partition that maximizes dp[i]

Return result

dp[n] contains the maximum sum for the entire array

Code -

solution.c — C

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

int maxSumAfterPartitioning(int* arr, int n, int k) {
    // dp[i] represents max sum for first i elements
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 1; i <= n; i++) {
        int maxVal = 0;
        // Try all possible partition lengths ending at position i-1
        int maxJ = (i < k) ? i : k;
        for (int j = 1; j <= maxJ; j++) {
            if (arr[i - j] > maxVal) {
                maxVal = arr[i - j]; // Max in current partition
            }
            // Current partition contributes maxVal * j + previous optimal
            int current = dp[i - j] + maxVal * j;
            if (current > dp[i]) {
                dp[i] = current;
            }
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse simple format: "1,15,7,9,2 3"
    char* token = strtok(input, " ");
    char* arrStr = token;
    int k = atoi(strtok(NULL, " "));
    
    int arr[100];
    int n = 0;
    token = strtok(arrStr, ",");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    printf("%d\n", maxSumAfterPartitioning(arr, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

For each of n positions, we check at most k previous positions to form partitions

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store maximum sums for each prefix

⚡ Linearithmic Space

51.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler