Maximum Product of Subsequences With an Alternating Sum Equal to K

Maximum Product of Subsequences With an Alternating Sum Equal to K - Problem

Maximum Product of Subsequences With an Alternating Sum Equal to K

You're given an integer array nums and two integers k and limit. Your mission is to find a non-empty subsequence from nums that satisfies two critical conditions:

1. Alternating Sum Constraint: The subsequence must have an alternating sum exactly equal to k
2. Product Maximization: Among all valid subsequences, find the one with the maximum product of its elements (without exceeding limit)

The alternating sum of a 0-indexed array is calculated as: sum of elements at even indices - sum of elements at odd indices

For example, if subsequence is [a, b, c, d], alternating sum = a - b + c - d

Goal: Return the maximum product of such a subsequence, or -1 if no valid subsequence exists.

Example: Given nums = [2, 3, -1, 4], k = 5, limit = 24
Subsequence [2, 3, 4] has alternating sum = 2 - 3 + 4 = 3 ≠ 5
Subsequence [3, -1, 4] has alternating sum = 3 - (-1) + 4 = 8 ≠ 5
We need to find the subsequence with alternating sum = 5 and maximum product ≤ 24.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 3, -1, 4], k = 5, limit = 24

› Output: 12

💡 Note: Subsequence [3, -1, 4] has alternating sum = 3 - (-1) + 4 = 8 ≠ 5. Subsequence [2, 4] has alternating sum = 2 + 4 = 6 ≠ 5. We need to find the right combination that gives exactly k=5.

example_2.py — Negative Numbers

$ Input: nums = [1, -2, 3, -4], k = 0, limit = 100

› Output: 24

💡 Note: Subsequence [1, -2, 3, -4] has alternating sum = 1 - (-2) + 3 - (-4) = 1 + 2 + 3 + 4 = 10 ≠ 0. Subsequence [-2, 3] has alternating sum = -2 + 3 = 1 ≠ 0. Need to find combination with sum = 0.

example_3.py — No Solution

$ Input: nums = [5, 5, 5], k = 1, limit = 50

› Output: -1

💡 Note: With only 5's in the array, possible alternating sums are 5, 0 (5-5), 15 (5-5+5), 10 (5+5), etc. No combination can produce alternating sum = 1, so return -1.

Constraints

1 ≤ nums.length ≤ 20
-1000 ≤ nums[i] ≤ 1000
-1000 ≤ k ≤ 1000
1 ≤ limit ≤ 10¹²
The array can contain negative numbers
Products can be negative

Visualization

Tap to expand

Understanding the Visualization

Stock Selection

Each array element represents a stock with a certain value

Market Cycles

Alternating positions represent bull (+) and bear (-) market effects

Target Profit

We need exactly k profit from the alternating market effects

Investment Limit

Total investment (product) cannot exceed our budget limit

Optimization

Among all valid portfolios, choose the one with maximum investment value

Key Takeaway

🎯 Key Insight: Use dynamic programming to efficiently explore all possible stock combinations, tracking both the alternating profit and investment value to find the optimal portfolio that meets our exact profit target while maximizing investment value within our budget limit.

Asked in

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

This problem requires finding a subsequence with a specific alternating sum while maximizing the product of its elements. The optimal approach uses dynamic programming with memoization to explore all possible subsequences efficiently, avoiding the exponential time complexity of pure brute force while still considering all valid combinations.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n * sum_range * 2^n)	O(n * sum_range)	Use recursive DP with memoization to avoid redundant calculations

Dynamic Programming with Memoization — Algorithm Steps

Define recursive function dp(index, current_sum, position, current_product)
At each index, we have 3 choices: skip element, include at even position, include at odd position
Use memoization to cache results for (index, current_sum, position) states
Base case: when index reaches end, check if current_sum equals k
Return maximum valid product found, or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with dp(0, 0, true) - at index 0, sum 0, expecting even position

Branching

For each element, branch into: skip, include at even pos, include at odd pos

Memoization

Cache results for (index, current_sum, position) to avoid recomputation

Pruning

Skip branches where product would exceed limit early

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    char key[100];
    long long value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

unsigned int hash(const char* key) {
    unsigned int hash = 0;
    while (*key) {
        hash = hash * 31 + *key++;
    }
    return hash % HASH_SIZE;
}

long long getMemo(const char* key) {
    unsigned int index = hash(key);
    HashNode* node = hashTable[index];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return LLONG_MIN; // Not found
}

void setMemo(const char* key, long long value) {
    unsigned int index = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    strcpy(node->key, key);
    node->value = value;
    node->next = hashTable[index];
    hashTable[index] = node;
}

int* globalNums;
int globalK;
long long globalLimit;
int globalN;

long long dp(int index, int currentSum, int isEvenPos) {
    if (index == globalN) {
        return currentSum == globalK ? 1 : -1;
    }
    
    char key[100];
    sprintf(key, "%d_%d_%d", index, currentSum, isEvenPos);
    
    long long memoResult = getMemo(key);
    if (memoResult != LLONG_MIN) {
        return memoResult;
    }
    
    long long maxProduct = -1;
    
    // Option 1: Skip current element
    long long result = dp(index + 1, currentSum, isEvenPos);
    if (result != -1) {
        if (maxProduct == -1 || result > maxProduct) {
            maxProduct = result;
        }
    }
    
    // Option 2: Include current element
    int newSum = isEvenPos ? currentSum + globalNums[index] : currentSum - globalNums[index];
    result = dp(index + 1, newSum, !isEvenPos);
    if (result != -1) {
        long long product = result * globalNums[index];
        if (product <= globalLimit) {
            if (maxProduct == -1 || product > maxProduct) {
                maxProduct = product;
            }
        }
    }
    
    setMemo(key, maxProduct);
    return maxProduct;
}

long long maxProductSubsequence(int* nums, int numsSize, int k, long long limit) {
    globalNums = nums;
    globalK = k;
    globalLimit = limit;
    globalN = numsSize;
    
    // Initialize hash table
    memset(hashTable, 0, sizeof(hashTable));
    
    // Try different starting configurations
    long long result1 = dp(1, nums[0], 0);
    if (result1 != -1) result1 *= nums[0];
    
    long long result2 = dp(1, 0, 1);
    
    long long finalResult = -1;
    if (result1 != -1 && result1 <= limit) {
        finalResult = result1;
    }
    if (result2 != -1 && result2 <= limit) {
        if (finalResult == -1 || result2 > finalResult) {
            finalResult = result2;
        }
    }
    
    return finalResult;
}

int main() {
    int nums[] = {2, 3, -1, 4};
    printf("%lld\n", maxProductSubsequence(nums, 4, 5, 24));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * sum_range * 2^n)

We have n indices, sum_range possible sums, but still up to 2^n states in worst case

⚠ Quadratic Growth

Space Complexity

O(n * sum_range)

Memoization table for all possible (index, sum) combinations

⚡ Linearithmic Space

52.0K Views

Medium-High Frequency

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

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler