Sum of Good Subsequences - Practice Coding Problems

Sum of Good Subsequences - Problem

You're given an integer array nums and need to find all "good subsequences" - but what makes a subsequence good?

A good subsequence is one where each pair of consecutive elements has an absolute difference of exactly 1. Think of it like a staircase where each step is exactly one unit up or down!

Your task: Calculate the sum of all elements in all possible good subsequences. Since this number can be astronomically large, return the result modulo 10⁹ + 7.

Key insights:

A single element is always a good subsequence
Elements don't need to be adjacent in the original array
Focus on consecutive differences in the subsequence, not original positions

Example: For [1, 2, 1], good subsequences include [1], [2], [1], [1,2], [2,1], and [1,2,1].

Input & Output

example_1.py — Basic Case

$ Input: [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.py — Single Element

$ Input: [3]

› Output: 3

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

example_3.py — No Adjacent Differences

$ Input: [1, 3, 5]

› Output: 9

💡 Note: No consecutive elements differ by 1, so only single-element subsequences are good: [1], [3], [5]. Total: 1+3+5 = 9

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
A subsequence of size 1 is always considered good
Return the result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Track Melody Endings

For each note value, remember how many melodies end there and their total value

Extend Compatible Melodies

When we see a new note, extend melodies ending one semitone away (±1)

Update State

Add the new note as both a solo melody and extension of existing ones

Accumulate Value

Sum all melody values created so far

Key Takeaway

🎯 Key Insight: Instead of generating all melodies explicitly, we track how many melodies end at each note and their total value, then efficiently extend compatible melodies as we encounter new notes!

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 29

The optimal solution uses dynamic programming with hash maps to track the count and sum of good subsequences ending at each value. For each element, we extend compatible subsequences (those ending at ±1 values) and update our state. This achieves O(n) time complexity by avoiding explicit subsequence generation.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Hash Map (Optimal)	O(n)	O(k)	Track sum and count of subsequences ending at each value
Brute Force (Generate All Subsequences)	O(n × 2^n)	O(n)	Generate all possible subsequences and check which ones are good

Dynamic Programming with Hash Map (Optimal) — Algorithm Steps

Initialize hash maps to track count and sum of subsequences ending at each value
For each element x, calculate how many subsequences can be extended
Update count and sum for subsequences ending at x
Add contribution of x as a single-element subsequence
Return total sum of all good subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Track count and sum for each ending value

Process Each Element

Extend compatible subsequences (±1 difference)

Update States

Add new subsequences ending at current element

Accumulate Result

Sum contributions from all elements

Code -

solution.c — C

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

#define MOD 1000000007
#define HASH_SIZE 100003

typedef struct HashNode {
    int key;
    long long count;
    long long sum;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];

int hash(int key) {
    return ((key % HASH_SIZE) + HASH_SIZE) % HASH_SIZE;
}

void insert(int key, long long count, long long sum) {
    int idx = hash(key);
    HashNode* node = hashTable[idx];
    
    while (node) {
        if (node->key == key) {
            node->count = count;
            node->sum = sum;
            return;
        }
        node = node->next;
    }
    
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->count = count;
    newNode->sum = sum;
    newNode->next = hashTable[idx];
    hashTable[idx] = newNode;
}

HashNode* find(int key) {
    int idx = hash(key);
    HashNode* node = hashTable[idx];
    
    while (node) {
        if (node->key == key) return node;
        node = node->next;
    }
    return NULL;
}

int sumOfGoodSubsequences(int* nums, int n) {
    memset(hashTable, 0, sizeof(hashTable));
    long long totalSum = 0;
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        long long count = 1;
        long long sumVal = num;
        
        HashNode* prev1 = find(num - 1);
        if (prev1) {
            count = (count + prev1->count) % MOD;
            sumVal = (sumVal + prev1->sum + prev1->count * num) % MOD;
        }
        
        HashNode* prev2 = find(num + 1);
        if (prev2) {
            count = (count + prev2->count) % MOD;
            sumVal = (sumVal + prev2->sum + prev2->count * num) % MOD;
        }
        
        insert(num, count, sumVal);
        totalSum = (totalSum + sumVal) % MOD;
    }
    
    return totalSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, constant time hash map operations

✓ Linear Growth

Space Complexity

O(k)

Hash maps store at most k unique values from the array

✓ Linear Space

43.4K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler