Maximum Alternating Subsequence Sum

Maximum Alternating Subsequence Sum - Problem

The alternating sum of a 0-indexed array is defined as the sum of the elements at even indices minus the sum of the elements at odd indices.

For example, the alternating sum of [4,2,5,3] is (4 + 5) - (2 + 3) = 4.

Given an array nums, return the maximum alternating sum of any subsequence of nums (after reindexing the elements of the subsequence).

A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the remaining elements' relative order. For example, [2,7,4] is a subsequence of [4,2,3,7,2,1,4] (the underlined elements), while [2,4,2] is not.

Input & Output

Example 1 — Basic Case

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

› Output: 7

💡 Note: Optimal subsequence is [4,2,5] with alternating sum 4-2+5 = 7

Example 2 — Single Element

$ Input: nums = [5,6,7,8]

› Output: 8

💡 Note: Take just the largest element [8] with alternating sum 8

Example 3 — Two Elements

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

› Output: 10

💡 Note: Optimal subsequence is [6,1,5] with alternating sum 6-1+5 = 10

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to think of this as a stock trading problem where we buy low and sell high. The optimal approach uses dynamic programming to track maximum profit when holding vs not holding stocks. Time: O(n), Space: O(1)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Use two variables to track the maximum alternating sum when the last element is at an even position (positive contribution) and when it's at an odd position (negative contribution).

Brute Force - Generate All Subsequences

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

Try every possible subsequence by using bit manipulation to represent which elements to include. For each subsequence, calculate the alternating sum and track the maximum.

Greedy Approach

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

We can reframe this as a stock trading problem where we start with 0 stocks and can buy (subtract value) or sell (add value). We want to maximize profit by buying low and selling high.

Memoization (Top-Down DP)

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

At each position, we can either include the current element (with positive or negative contribution based on position) or skip it. Use memoization to store results for each state.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Initialize even = 0 (max sum ending at even position) and odd = 0
Step 2: For each element, update even and odd based on best choices
Step 3: Return the maximum of even (since we want positive contribution last)

Visualization

Tap to expand

Step-by-Step Walkthrough

States

Track max sum at even/odd positions

Update

For each element, update both states

Result

Return even state (positive contribution)

Code -

solution.c — C

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

long long solution(int* nums, int numsSize) {
    // even: max sum when we have even number of elements (next element adds)
    // odd: max sum when we have odd number of elements (next element subtracts)
    long long even = 0;
    long long odd = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // Update states
        long long newEven = (even > odd + nums[i]) ? even : (odd + nums[i]);
        long long newOdd = (odd > even - nums[i]) ? odd : (even - nums[i]);
        
        even = newEven;
        odd = newOdd;
    }
    
    return even;  // We want maximum when last element contributes positively
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    long long result = solution(nums, numsSize);
    printf("%lld\n", result);
    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 using two variables to track states

✓ Linear Space

52.0K Views

Medium Frequency

~25 min Avg. Time

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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler