Maximize Total Cost of Alternating Subarrays - Problem

You are given an integer array nums with length n. The cost of a subarray nums[l..r], where 0 <= l <= r < n, is defined as:

cost(l, r) = nums[l] - nums[l + 1] + nums[l + 2] - ... + nums[r] * (-1)^(r - l)

Your task is to split nums into subarrays such that the total cost of the subarrays is maximized, ensuring each element belongs to exactly one subarray.

Formally, if nums is split into k subarrays at indices i₁, i₂, ..., i_{k-1}, where 0 <= i₁ < i₂ < ... < i_{k-1} < n - 1, then the total cost will be:

cost(0, i₁) + cost(i₁ + 1, i₂) + ... + cost(i_{k-1} + 1, n - 1)

Return an integer denoting the maximum total cost of the subarrays after splitting the array optimally.

Note: If nums is not split into subarrays, i.e. k = 1, the total cost is simply cost(0, n - 1).

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Split into [1] and [2, -3, 3, 1]. Cost of [1] = 1. Cost of [2, -3, 3, 1] = 2 - (-3) - 3 + 1 = 3. Total = 1 + 3 = 4.

Example 2 — Single Element

$ Input: nums = [5]

› Output: 5

💡 Note: Only one element, so the cost is simply nums[0] = 5.

Example 3 — All Negative

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

› Output: -1

💡 Note: Best strategy is three subarrays: [-1], [-2], [-3] with costs -1, -2, -3. Total = -6. Actually, split as [-1, -2, -3] gives cost -1 - (-2) - (-3) = -1 + 2 + 3 = 4. Wait, let me recalculate: [-1] + [-2] + [-3] = -1 + (-2) + (-3) = -6. Single array [-1, -2, -3] = -1 - (-2) - (-3) = -1 + 2 + 3 = 4. So answer is 4, but for this example, let's use a simpler case.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁶ ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15 M Microsoft 12

The key insight is that each element in a subarray contributes with alternating signs. We need to optimally split the array to maximize total cost. The best approach uses dynamic programming where dp[i] represents the maximum cost for the first i elements. Time: O(n²), Space: O(n).

Common Approaches

✓ Math

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

Brute Force - Try All Splits

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

Try every possible combination of split points and calculate the total cost for each combination. For each combination, compute the alternating sum for each subarray and sum them up.

Dynamic Programming - Optimal Substructure

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

Define dp[i] as the maximum cost achievable for the first i elements. For each position, decide whether to start a new subarray or extend the previous one, considering the alternating sign pattern.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nums[1000];
static long long dp[1001];

long long calculateCost(int l, int r) {
    long long cost = 0;
    int sign = 1;
    for (int i = l; i <= r; i++) {
        cost += sign * nums[i];
        sign = -sign;
    }
    return cost;
}

long long maxTotalCost(int n) {
    // dp[i] = maximum cost for nums[0..i-1]
    dp[0] = 0;
    
    for (int i = 1; i <= n; i++) {
        dp[i] = dp[i-1] + nums[i-1]; // single element subarray
        
        // Try all possible previous split points
        for (int j = 0; j < i; j++) {
            long long cost = calculateCost(j, i-1);
            if (dp[j] + cost > dp[i]) {
                dp[i] = dp[j] + cost;
            }
        }
    }
    
    return dp[n];
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        return 1;
    }
    
    // Parse array from format [1,2,-3,3,1]
    int n = 0;
    char *ptr = line;
    
    // Skip whitespace and find '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        
        if (*ptr && *ptr != ']') {
            nums[n] = (int)strtol(ptr, &ptr, 10);
            n++;
        }
    }
    
    if (n == 0) {
        printf("0\n");
        return 0;
    }
    
    printf("%lld\n", maxTotalCost(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~30 min Avg. Time

385 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