Maximum Balanced Subsequence Sum - Practice Coding Problems

Maximum Balanced Subsequence Sum - Problem

You're given a 0-indexed integer array nums and need to find the maximum sum of a special type of subsequence called a balanced subsequence.

A subsequence with indices i₀ < i₁ < ... < iₖ₋₁ is balanced if for every consecutive pair of elements:

nums[iⱼ] - nums[iⱼ₋₁] ≥ iⱼ - iⱼ₋₁ for all j ∈ [1, k-1]

In simpler terms, the value difference between consecutive elements must be at least as large as their index difference. This ensures the subsequence grows "fast enough" relative to how spread out the indices are.

Goal: Return the maximum possible sum of elements in any balanced subsequence. Note that a single element is always considered balanced.

Example: For nums = [3, -1, 1, 2], the subsequence at indices [0, 3] gives us [3, 2]. Check: 2 - 3 = -1 and 3 - 0 = 3, so -1 ≥ 3 is false, making this not balanced.

Input & Output

example_1.py — Basic case with mixed values

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

› Output: 3

💡 Note: The best balanced subsequence is just the single element [3] at index 0. Other subsequences like [3, 2] fail the balance check: (2-3) = -1 < (3-0) = 3.

example_2.py — All negative values

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

› Output: -1

💡 Note: Since all values are negative, the best strategy is to pick the single largest element, which is -1 at index 0.

example_3.py — Increasing subsequence

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

› Output: 26

💡 Note: The entire array forms a balanced subsequence: differences are [1,1,1] and index gaps are [1,1,1], so 1 ≥ 1 for all pairs. Sum = 5+6+7+8 = 26.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Transform Problem

Convert balance condition to: transformed[j] ≥ transformed[i] where transformed[k] = nums[k] - k

Coordinate Compression

Map potentially large value ranges to compact array indices for efficient processing

Dynamic Programming

Use segment tree to quickly find the best previous position that satisfies the constraint

Optimal Selection

Build up the maximum sum by considering each position and its optimal predecessors

Key Takeaway

🎯 Key Insight: Transform the balance condition algebraically and use advanced data structures to handle the complex constraint efficiently in O(n log n) time.

Asked in

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

The optimal approach uses dynamic programming with coordinate compression and segment trees. Transform the balance condition to nums[j] - j ≥ nums[i] - i, compress coordinates, and use segment trees for efficient range maximum queries. This achieves O(n log n) time complexity while handling the complex subsequence constraints elegantly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsequences)	O(n × 2ⁿ)	O(n)	Generate all possible subsequences and check balance condition
Dynamic Programming with Coordinate Compression	O(n log n)	O(n)	Use DP with coordinate compression and segment tree for efficient range maximum queries

Brute Force (Try All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation or recursion
For each subsequence, check if it's balanced by verifying the condition for consecutive pairs
Calculate the sum of balanced subsequences and track the maximum
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequence

Use bit mask to select elements

Check Balance

Verify consecutive pairs satisfy the condition

Calculate Sum

If balanced, compute sum and update maximum

Code -

solution.c — C

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

long long maxBalancedSubsequenceSum(int* nums, int n) {
    long long maxSum = nums[0];
    for (int i = 1; i < n; i++) {
        if (nums[i] > maxSum) maxSum = nums[i];
    }
    
    // Try all possible subsequences
    for (int mask = 1; mask < (1 << n); mask++) {
        int indices[20];
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                indices[count++] = i;
            }
        }
        
        // Check if balanced
        int isBalanced = 1;
        for (int j = 1; j < count; j++) {
            int currIdx = indices[j], prevIdx = indices[j-1];
            if (nums[currIdx] - nums[prevIdx] < currIdx - prevIdx) {
                isBalanced = 0;
                break;
            }
        }
        
        if (isBalanced) {
            long long currentSum = 0;
            for (int j = 0; j < count; j++) {
                currentSum += nums[indices[j]];
            }
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    return maxSum;
}

int main() {
    int nums[100];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%lld\n", maxBalancedSubsequenceSum(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

2ⁿ subsequences to check, each taking O(n) time to validate

✓ Linear Growth

Space Complexity

O(n)

Space for storing current subsequence being examined

⚡ Linearithmic Space

26.3K Views

Medium Frequency

~35 min Avg. Time

856 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 Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler