Sum of Good Subsequences

Sum of Good Subsequences - Problem

You are given an integer array nums. A good subsequence is defined as a subsequence of nums where the absolute difference between any two consecutive elements in the subsequence is exactly 1.

Return the sum of all possible good subsequences of nums. Since the answer may be very large, return it modulo 10^9 + 7.

Note that a subsequence of size 1 is considered good by definition.

Input & Output

Example 1 — Basic Case

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

› Output: 14

💡 Note: Good subsequences: [1] (sum=1), [2] (sum=2), [1] (sum=1), [1,2] (sum=3), [2,1] (sum=3), [1,2,1] (sum=4). Total: 1+2+1+3+3+4 = 14

Example 2 — Single Element

$ Input: nums = [3]

› Output: 3

💡 Note: Only one good subsequence: [3] with sum 3

Example 3 — No Extensions

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

› Output: 9

💡 Note: No consecutive elements differ by exactly 1. Good subsequences are only single elements: [1], [3], [5]. Total: 1+3+5 = 9

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that each element can extend subsequences ending at value±1. The optimal Dynamic Programming with Hash Map approach tracks count and sum of subsequences ending at each value. Time: O(n), Space: O(k) where k is unique values.

Common Approaches

✓ Brute Force - Generate All Subsequences

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

Generate all 2^n possible subsequences of the array, check if each subsequence is good (consecutive elements differ by exactly 1), and sum all valid subsequences.

Dynamic Programming with Hash Map

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

For each element, track how many subsequences end at each value and their sum. Each new element can extend subsequences ending at value-1 and value+1, or start a new single-element subsequence.

Recursive Memoization

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

Use recursive approach to explore all possible ways to extend subsequences, with memoization to cache results for (index, lastValue) pairs to avoid redundant calculations.

Brute Force - Generate All Subsequences — Algorithm Steps

Generate all 2^n subsequences using bit manipulation
For each subsequence, check if consecutive elements differ by exactly 1
Sum all valid good subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n subsequences using bit masks

Validate

Check if consecutive elements differ by exactly 1

Sum

Add valid subsequence sums to total

Code -

solution.c — C

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

int solution(int* nums, int n) {
    const int MOD = 1000000007;
    long long totalSum = 0;
    
    // Generate all 2^n subsequences
    for (int mask = 1; mask < (1 << n); mask++) {
        int subseq[20];
        int subseqLen = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[subseqLen++] = nums[i];
            }
        }
        
        // Check if subsequence is good
        int isGood = 1;
        for (int i = 1; i < subseqLen; i++) {
            if (abs(subseq[i] - subseq[i-1]) != 1) {
                isGood = 0;
                break;
            }
        }
        
        if (isGood) {
            long long sum = 0;
            for (int i = 0; i < subseqLen; i++) {
                sum += subseq[i];
            }
            totalSum = (totalSum + sum) % MOD;
        }
    }
    
    return totalSum;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subsequence

⚡ Linearithmic Space

15.4K Views

Medium Frequency

~35 min Avg. Time

284 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 - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler