Maximum Balanced Subsequence Sum

Maximum Balanced Subsequence Sum - Problem

You are given a 0-indexed integer array nums. A subsequence of nums having length k and consisting of indices i₀ < i₁ < ... < iₖ₋₁ is balanced if the following holds:

nums[iⱼ] - nums[iⱼ₋₁] >= iⱼ - iⱼ₋₁, for every j in the range [1, k - 1].

A subsequence of nums having length 1 is considered balanced.

Return an integer denoting the maximum possible sum of elements in a balanced subsequence of nums.

A subsequence of an array is a new non-empty array that is formed from the original array by deleting some (possibly none) of the elements without disturbing the relative positions of the remaining elements.

Input & Output

Example 1 — Basic Balanced Subsequence

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

› Output: 12

💡 Note: The balanced subsequence [3,4,5] at indices [0,1,2] gives maximum sum. Check: 4-3 ≥ 1-0 (1≥1 ✓), 5-4 ≥ 2-1 (1≥1 ✓). Sum = 3+4+5 = 12.

Example 2 — Single Element Maximum

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

› Output: -1

💡 Note: All single elements are balanced. The maximum single element is -1, so return -1.

Example 3 — Non-consecutive Subsequence

$ Input: nums = [5,-1,-3,8]

› Output: 13

💡 Note: The balanced subsequence [5,8] at indices [0,3] gives maximum sum. Check: 8-5 ≥ 3-0 (3≥3 ✓). Sum = 5+8 = 13.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15 f Meta 12

The key insight is to transform the balance condition by rearranging terms to nums[i] - i ≥ nums[j] - j. This allows us to use dynamic programming with coordinate compression and Binary Indexed Tree for efficient range maximum queries. Best approach achieves O(n log n) time and O(n) space.

Common Approaches

✓ Brute Force - Check All Subsequences

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

Generate all possible subsequences of the array, check if each subsequence satisfies the balance condition, and track the maximum sum among valid subsequences.

Coordinate Compression + Binary Indexed Tree

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

Transform the problem using coordinate compression on the transformed values, then use a Binary Indexed Tree (Fenwick Tree) to efficiently find the maximum DP value for valid previous positions.

Dynamic Programming

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

Transform the balance condition by rearranging terms. Use dynamic programming where dp[i] represents the maximum sum of a balanced subsequence ending at index i.

Brute Force - Check All Subsequences — Algorithm Steps

Generate all 2^n possible subsequences
For each subsequence, verify balance condition
Track maximum sum of valid subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n possible subsequences using bit masks

Validate

Check balance condition for each subsequence

Result

Return maximum sum among valid subsequences

Code -

solution.c — C

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

long long solution(int* nums, int n) {
    long long maxSum = LLONG_MIN;
    
    // Try all possible subsequences using bit manipulation
    for (int mask = 1; mask < (1 << n); mask++) {
        int subsequence[20], indices[20];
        int subLen = 0;
        
        // Extract subsequence based on mask
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen] = nums[i];
                indices[subLen] = i;
                subLen++;
            }
        }
        
        // Check if subsequence is balanced
        int isBalanced = 1;
        for (int j = 1; j < subLen; j++) {
            if (nums[indices[j]] - nums[indices[j-1]] < indices[j] - indices[j-1]) {
                isBalanced = 0;
                break;
            }
        }
        
        // Update maximum sum if balanced
        if (isBalanced) {
            long long sum = 0;
            for (int i = 0; i < subLen; i++) {
                sum += subsequence[i];
            }
            if (sum > maxSum) maxSum = sum;
        }
    }
    
    return maxSum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[20], n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    long long result = solution(nums, n);
    printf("%lld\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n subsequences, each taking O(n) time to validate

✓ Linear Growth

Space Complexity

O(n)

Space for storing current subsequence during generation

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

342 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 - Check All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler