Maximize Total Cost of Alternating Subarrays

Maximize Total Cost of Alternating Subarrays - Problem

Maximize Total Cost of Alternating Subarrays

You are given an integer array nums of length n. Your goal is to strategically split this array into subarrays to maximize the total cost.

The cost of a subarray nums[l..r] (where 0 ≤ l ≤ r < n) follows an alternating pattern:
cost(l, r) = nums[l] - nums[l + 1] + nums[l + 2] - nums[l + 3] + ...

In other words, we add elements at even positions relative to the start and subtract elements at odd positions.

Your Task: Split nums into one or more subarrays such that each element belongs to exactly one subarray and the total cost is maximized.

Example: For array [1, -2, 3, 4], you could split it as [1, -2] and [3, 4] giving costs (1 - (-2)) + (3 - 4) = 3 + (-1) = 2.

Input & Output

example_1.py — Basic Case

$ Input: [1, -2, 3, 4]

› Output: 10

💡 Note: We can split the array as [1, -2, 3] + [4]. The first subarray gives cost 1 - (-2) + 3 = 6, and the second gives cost 4. Total: 6 + 4 = 10.

example_2.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: With only one element, the cost is simply 5 (no alternating pattern needed).

example_3.py — Negative Values

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

› Output: -1

💡 Note: Best strategy is to split as [-1] + [-2] + [-3], giving costs -1 + (-2) + (-3) = -6. Actually, the optimal is to use [-1, -2, -3] as one subarray: -1 - (-2) + (-3) = -1 + 2 - 3 = -2. But splitting as [-1] + [-2] + [-3] gives -1 + (-2) + (-3) = -6. The optimal is actually [-1] which gives -1.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
The array must be split such that each element belongs to exactly one subarray

Visualization

Tap to expand

Understanding the Visualization

Initialize Trading

Start first trading session by buying the first stock

Make Decisions

At each stock, decide: continue current session or start new session

Track States

Maintain maximum profit for both 'just bought' and 'just sold' states

Optimal Choice

Choose the action that maximizes total profit across all sessions

Key Takeaway

🎯 Key Insight: At each position, we can either continue the current trading session (alternating buy/sell) or start a new session (always begins with buy). Dynamic programming helps us track the maximum profit for both states and make optimal decisions.

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses dynamic programming with two states: tracking maximum cost when current element has positive coefficient (start of subarray) vs negative coefficient (continuation). At each position, we decide whether to continue the current subarray or start a new one, choosing the option that maximizes total cost. Time complexity is O(n) with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(2^n × n)	O(n)	Generate all possible ways to split the array and calculate the maximum cost
Dynamic Programming (Optimal)	O(n)	O(1)	Use memoization to track maximum cost at each position with alternating states

Brute Force (Try All Splits) — Algorithm Steps

Generate all possible split points (2^(n-1) possibilities)
For each split configuration, divide array into subarrays
Calculate alternating cost for each subarray
Sum up all subarray costs
Track the maximum total cost across all configurations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Splits

Create all possible ways to partition the array

Calculate Costs

For each partition, calculate alternating sum of each subarray

Track Maximum

Keep track of the configuration with maximum total cost

Code -

solution.c — C

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

int maxCost = INT_MIN;

int calculateSubarrayCost(int* nums, int start, int end) {
    int cost = 0;
    for (int i = start; i <= end; i++) {
        if ((i - start) % 2 == 0) {
            cost += nums[i];
        } else {
            cost -= nums[i];
        }
    }
    return cost;
}

void generateAllSplits(int* nums, int n, int index, int* currentSplits, int splitCount) {
    if (index == n) {
        int totalCost = 0;
        int start = 0;
        
        for (int i = 0; i < splitCount; i++) {
            totalCost += calculateSubarrayCost(nums, start, currentSplits[i] - 1);
            start = currentSplits[i];
        }
        totalCost += calculateSubarrayCost(nums, start, n - 1);
        
        if (totalCost > maxCost) {
            maxCost = totalCost;
        }
        return;
    }
    
    generateAllSplits(nums, n, index + 1, currentSplits, splitCount);
    
    if (index < n - 1) {
        currentSplits[splitCount] = index + 1;
        generateAllSplits(nums, n, index + 1, currentSplits, splitCount + 1);
    }
}

int maximumTotalCost(int* nums, int n) {
    maxCost = INT_MIN;
    int* currentSplits = (int*)malloc(n * sizeof(int));
    generateAllSplits(nums, n, 0, currentSplits, 0);
    free(currentSplits);
    return maxCost;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parsing for [1,2,3,4] format
    int nums[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maximumTotalCost(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^(n-1) ways to split the array, and O(n) time to calculate cost for each split

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current partition

⚡ Linearithmic Space

43.7K Views

Medium Frequency

~25 min Avg. Time

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

Brute Force (Try All Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler