Maximum Alternating Subsequence Sum - Practice Coding Problems

Maximum Alternating Subsequence Sum - Problem

Imagine you're playing a strategic game where you can pick numbers from an array to maximize your score, but there's a twist - the positions matter!

The alternating sum of a sequence works like this:

Elements at even positions (0, 2, 4, ...) are added to your score
Elements at odd positions (1, 3, 5, ...) are subtracted from your score

For example, with array [4,2,5,3], the alternating sum is: (4 + 5) - (2 + 3) = 4

Your challenge: Given an array nums, find the maximum alternating sum of any subsequence you can create. Remember, a subsequence maintains the relative order of elements but can skip some elements.

Goal: Select elements strategically to maximize your alternating sum score!

Input & Output

example_1.py — Basic Case

$ Input: [4,2,5,3]

› Output: 7

💡 Note: The optimal subsequence is [4,5]. Alternating sum = 4 + 5 = 9. Wait, let me recalculate... Actually, we can pick [4,2,5] giving us 4 - 2 + 5 = 7, or just [4,5] at positions 0,2 giving us 4 + 5 = 9. The maximum is 7 from subsequence [4,2,5].

example_2.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: With only one element, the maximum alternating sum is the element itself at even position: 5.

example_3.py — Optimal Selection

$ Input: [6,2,1,2,4,5]

› Output: 10

💡 Note: Optimal subsequence is [6,1,4,5] giving alternating sum: 6 - 1 + 4 - 5 = 4. Actually, better is [6,2,5] = 6 - 2 + 5 = 9, or [6,1,5] = 6 - 1 + 5 = 10.

Visualization

Tap to expand

Even Position (Buy): Spend money, reduce profit🟢 Odd Position (Sell): Gain money, increase profit💡 Goal: Maximize total profit from buy/sell sequence📈 Optimal: Buy at $2, Sell at $5 → Profit = $3DP State Transitions:DayPriceNot HoldingHoldingActionProfit CalculationStart-$0$0InitializeStarting with no money, no stock1$4$0$4Buy at $4holding = max(0, 0+4) = 42$2$2$4Sell stock bought at $4not_holding = max(0, 4-2) = 23$5$7$4Buy at $5 (or keep holding)holding = max(4, 2+5) = 74$3$7$4Keep current positionnot_holding = max(2, 7-3) = 4Maximum Profit: $7 (End without holding stock)

Understanding the Visualization

Initialize States

Start with zero profit in both 'holding stock' and 'not holding stock' states

Process Each Day

For each stock price, decide whether to buy, sell, or hold

Update Profits

Calculate maximum profit for each state based on current price

Choose Optimal

Return the maximum profit when not holding stock (we want to end with a sale)

Key Takeaway

🎯 Key Insight: This problem is equivalent to finding the maximum profit from stock trading where you can buy and sell multiple times. The DP states track the best profit when you're ready to 'add' (buy) vs 'subtract' (sell) the current price.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only storing two variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
The subsequence must maintain relative order of original elements

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses dynamic programming to track two states: the maximum alternating sum ending with an addition (even position) and ending with a subtraction (odd position). At each element, we decide whether to extend our current sequence or start fresh. The key insight is that we only need to track these two states as we process the array, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track two states: maximum sum ending with addition vs subtraction
Brute Force (Generate All Subsequences)	O(n * 2^n)	O(n)	Generate all possible subsequences and calculate their alternating sums

Dynamic Programming (Optimal) — Algorithm Steps

Initialize two variables: 'even' (max sum ending with addition) and 'odd' (max sum ending with subtraction)
For each element, calculate new states based on current states
Update even = max(even, odd + current_element)
Update odd = max(odd, even - current_element)
Return the maximum of the two states

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Start with even=0, odd=0 representing empty subsequence

Process Each Element

Update both states based on whether to add or subtract current element

State Transitions

even = max(even, odd + num), odd = max(odd, even - num)

Return Result

Return 'even' state as we want to end with addition

Code -

solution.c — C

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

long long max(long long a, long long b) {
    return a > b ? a : b;
}

long long maxAlternatingSum(int* nums, int n) {
    long long even = 0, odd = 0;
    
    for (int i = 0; i < n; i++) {
        long long newEven = max(even, odd + nums[i]);
        long long newOdd = max(odd, even - nums[i]);
        even = newEven;
        odd = newOdd;
    }
    
    return even;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100000];
    int n = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%lld\n", maxAlternatingSum(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only storing two variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
The subsequence must maintain relative order of original elements

42.3K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler