Maximum Strength of K Disjoint Subarrays - Practice Coding Problems

Maximum Strength of K Disjoint Subarrays - Problem

You're given an array of integers nums with length n, and a positive odd integer k. Your mission is to strategically select exactly k disjoint subarrays to maximize their combined strength.

Key Rules:

The subarrays must be disjoint (non-overlapping)
They must appear in order: the last element of subarray i comes before the first element of subarray i+1
You don't need to use every element in the original array

Strength Formula:
The strength alternates between positive and negative coefficients:
strength = k × sum(sub₁) - (k-1) × sum(sub₂) + (k-2) × sum(sub₃) - ... + sum(subₖ)

For example, with k=3: 3×sum(sub₁) - 2×sum(sub₂) + 1×sum(sub₃)

Return the maximum possible strength you can achieve by optimally selecting k disjoint subarrays.

Input & Output

example_1.py — Basic Example

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

› Output: 22

💡 Note: Select subarrays [1, 2], [3], [-1, 2] with strength = 3×(1+2) - 2×(3) + 1×(-1+2) = 9 - 6 + 1 = 4. But optimal is [1, 2, 3], [-1], [2] giving 3×6 - 2×(-1) + 1×2 = 18 + 2 + 2 = 22.

example_2.py — Negative Numbers

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

› Output: -1

💡 Note: With k=1, we need exactly one subarray. The best choice is [-1] with strength = 1×(-1) = -1, which is better than [-2] or [-3] or any longer subarray.

example_3.py — Mixed Values

$ Input: nums = [5, -3, 5], k = 3

› Output: 13

💡 Note: Select subarrays [5], [-3], [5] with strength = 3×5 - 2×(-3) + 1×5 = 15 + 6 - 2 = 19. Wait, that's wrong calculation. Actually: 3×5 - 2×(-3) + 1×5 = 15 + 6 + 5 = 26. But we need to verify this is the optimal solution.

Constraints

1 ≤ n ≤ 10⁴
1 ≤ k ≤ n
k is odd
-10⁹ ≤ nums[i] ≤ 10⁹
The subarrays must be disjoint and in order

Visualization

Tap to expand

Understanding the Visualization

Identify Opportunities

Scan the array to identify potential high-value subarrays

Apply Strategy

Use DP to systematically try different combinations

Calculate Weighted Impact

Apply alternating coefficients: positive for odd positions, negative for even

Optimize Selection

Choose the combination that maximizes total strength

Key Takeaway

🎯 Key Insight: Use dynamic programming to systematically explore all valid combinations while efficiently handling the alternating coefficient pattern in the strength calculation.

Asked in

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

The optimal approach uses Dynamic Programming with state dp[i][j] representing the maximum strength using the first i elements with exactly j subarrays. The key insight is handling the alternating coefficients in the strength formula while ensuring subarrays remain disjoint and ordered. Time complexity is O(n²×k).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n² × k)	O(n × k)	Use DP to build optimal solution by tracking states: position, subarrays used, and current status

Dynamic Programming (Optimal) — Algorithm Steps

Define DP state: dp[pos][count][in_subarray] = maximum strength
For each position, decide whether to start/continue/end a subarray
Use memoization to avoid recomputing the same states
Handle the alternating coefficients in the strength calculation
Return the maximum strength achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

Create dp[i][j] for position i with j subarrays used

Fill Base Cases

Set dp[0][0] = 0 as starting point

State Transitions

For each position, try including or excluding elements

Calculate Coefficients

Apply alternating positive/negative multipliers

Return Result

The answer is dp[n][k]

Code -

solution.c — C

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

long long maximumStrength(int* nums, int numsSize, int k) {
    int n = numsSize;
    // dp[i][j] = maximum strength using first i elements with j subarrays
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)malloc((k + 1) * sizeof(long long));
        for (int j = 0; j <= k; j++) {
            dp[i][j] = LLONG_MIN / 2;
        }
    }
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            // Don't use nums[i-1]
            dp[i][j] = dp[i-1][j];
            
            // Use nums[i-1] as part of j-th subarray
            if (j > 0) {
                long long coeff = ((j - 1) % 2 == 0) ? (k - j + 1) : -(k - j + 1);
                
                // Try all possible starting positions
                for (int start = 0; start < i; start++) {
                    long long subarraySum = 0;
                    for (int idx = start; idx < i; idx++) {
                        subarraySum += nums[idx];
                    }
                    
                    long long prevDp = (start > 0) ? dp[start][j-1] : (j == 1 ? 0 : LLONG_MIN / 2);
                    
                    if (prevDp != LLONG_MIN / 2) {
                        long long newVal = prevDp + coeff * subarraySum;
                        if (newVal > dp[i][j]) {
                            dp[i][j] = newVal;
                        }
                    }
                }
            }
        }
    }
    
    long long result = dp[n][k];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

We have O(n×k) states, and each state may need O(n) time to compute in worst case

⚠ Quadratic Growth

Space Complexity

O(n × k)

Memoization table stores results for all possible states

⚡ Linearithmic Space

27.4K Views

Medium Frequency

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler