Constrained Subsequence Sum - Practice Coding Problems

Constrained Subsequence Sum - Problem

Array Dynamic Programming Queue Sliding Window Heap (Priority Queue) Monotonic Queue Hard

Constrained Subsequence Sum

You're given an integer array nums and an integer k. Your task is to find the maximum sum of a non-empty subsequence where consecutive elements in the subsequence have a special constraint.

🎯 The Constraint: For any two consecutive integers in your chosen subsequence, nums[i] and nums[j] where i < j, the condition j - i <= k must be satisfied.

What's a subsequence? It's obtained by deleting some elements (possibly zero) from the original array while keeping the remaining elements in their original relative order.

Example: If nums = [10,2,-10,5,20] and k = 2, you could choose subsequence [10, 5, 20] (indices 0, 3, 4) because the gaps are 3-0=3 > 2... wait, that violates the constraint! You need gaps ≤ k between consecutive picks.

Input & Output

example_1.py — Basic case

$ Input: nums = [10,2,-10,5,20], k = 2

› Output: 37

💡 Note: The optimal subsequence is [10, 5, 20]. We can choose index 0 (value 10), then index 3 (value 5) since 3-0=3 > 2, this violates constraint. Actually, we need to check: we can go 0→3 if 3-0 ≤ 2? No. So we try 0→1→3→4: gaps are 1,2,1 all ≤ 2. Sum = 10+2+5+20=37.

example_2.py — Negative values

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

› Output: -1

💡 Note: All values are negative, so we must choose at least one element. The best choice is the largest (least negative) value, which is -1.

example_3.py — Large gap constraint

$ Input: nums = [10,-2,5,6], k = 3

› Output: 21

💡 Note: With k=3, we can jump at most 3 positions. The optimal subsequence is [10, 5, 6] with indices [0, 2, 3]. Gaps are 2-0=2 ≤ 3 and 3-2=1 ≤ 3. Sum = 10+5+6=21.

Visualization

Tap to expand

Understanding the Visualization

Setup the Path

Each array position is a station with a reward/penalty value

Apply the Constraint

Runner can only jump at most k stations ahead (j - i ≤ k)

Use Smart Memory

At each station, remember the best total reward from previous k stations

Make Optimal Choice

Either start fresh at current station or add current reward to best previous total

Key Takeaway

🎯 Key Insight: Use a monotonic deque to efficiently track the maximum DP value in a sliding window of size k, enabling O(n) time complexity instead of O(nk).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is added and removed from deque at most once, making it O(n) amortized

✓ Linear Growth

Space Complexity

O(n)

DP array takes O(n) space, deque stores at most k elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
1 ≤ k ≤ nums.length
The subsequence must be non-empty

Asked in

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

The optimal solution uses Dynamic Programming with Monotonic Deque to achieve O(n) time complexity. The key insight is that at each position, we only need to consider the maximum DP value from the previous k positions, which can be efficiently maintained using a monotonic decreasing deque.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsequences)	O(2^n)	O(n)	Generate all possible subsequences and check constraint validity
Dynamic Programming + Monotonic Deque (Optimal)	O(n)	O(n)	Use DP with sliding window maximum via monotonic deque

Brute Force (Try All Subsequences) — Algorithm Steps

Generate all 2^n possible subsequences using bit manipulation
For each subsequence, verify that consecutive elements satisfy j - i <= k
Calculate the sum of valid subsequences
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Bitmasks

Create all possible combinations using binary representation

Build Subsequence

For each mask, extract elements where bit is set

Check Constraint

Verify consecutive elements are within k distance

Track Maximum

Keep the highest sum among valid subsequences

Code -

solution.c — C

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

int constrainedSubsetSum(int* nums, int numsSize, int k) {
    int maxSum = INT_MIN;
    
    // Try all possible subsequences (2^n combinations)
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        int subsequence[20];
        int indices[20];
        int subLen = 0;
        
        // Build subsequence based on bitmask
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen] = nums[i];
                indices[subLen] = i;
                subLen++;
            }
        }
        
        // Check if subsequence satisfies constraint
        int valid = 1;
        for (int i = 1; i < subLen; i++) {
            if (indices[i] - indices[i-1] > k) {
                valid = 0;
                break;
            }
        }
        
        // Update maximum if valid
        if (valid) {
            int sum = 0;
            for (int i = 0; i < subLen; i++) {
                sum += subsequence[i];
            }
            if (sum > maxSum) {
                maxSum = sum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    int nums[20];
    int numsSize = 0;
    int k;
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    
    printf("%d\n", constrainedSubsetSum(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^n subsequences and check each one

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing current subsequence

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
1 ≤ k ≤ nums.length
The subsequence must be non-empty

67.8K Views

High Frequency

~25 min Avg. Time

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

Brute Force (Try All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler