Distinct Subsequences II - Practice Coding Problems

Distinct Subsequences II - Problem

Given a string s, you need to find the number of distinct non-empty subsequences that can be formed from this string.

A subsequence is formed by deleting some (possibly zero) characters from the original string while maintaining the relative order of the remaining characters. For example, "ace" is a subsequence of "abcde", but "aec" is not.

Important: Two subsequences are considered different if they differ in at least one position. Since the answer can be extremely large, return the result modulo 10⁹ + 7.

Example: For string "abc", the distinct subsequences are: "a", "b", "c", "ab", "ac", "bc", "abc" → Total: 7

Input & Output

example_1.py — Basic Case

$ Input: s = "abc"

› Output: 7

💡 Note: The distinct subsequences are: "a", "b", "c", "ab", "ac", "bc", "abc". Total count is 7.

example_2.py — Duplicate Characters

$ Input: s = "aba"

› Output: 6

💡 Note: The distinct subsequences are: "a", "b", "ab", "ba", "aba", "aa". Note that "a" appears only once in the count despite being formed in multiple ways.

example_3.py — Single Character

$ Input: s = "aaa"

› Output: 3

💡 Note: The distinct subsequences are: "a", "aa", "aaa". Even though there are many ways to form these, we count only distinct ones.

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with no subsequences, dp array all zeros

Process Each Character

For each character c, create new subsequences by appending c to all existing ones

Handle Duplicates

When character repeats, overwrite old count to avoid duplicate subsequences

Count Total

Sum all dp values to get total distinct subsequences

Key Takeaway

🎯 Key Insight: By tracking subsequences ending with each character and using the formula `new_count = sum(all_dp) + 1`, we efficiently count distinct subsequences while automatically handling duplicates through overwrites.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, with constant work per character

✓ Linear Growth

Space Complexity

O(1)

Fixed size array of 26 elements for tracking characters a-z

✓ Linear Space

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase English letters only
Return the answer modulo 10⁹ + 7

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses dynamic programming with character tracking. We maintain an array where dp[i] represents the count of distinct subsequences ending with character i. For each new character, we calculate new_count = sum(all dp values) + 1, then update dp[current_char] = new_count. This elegantly handles duplicates by overwriting previous counts. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Subsequences	O(2^n)	O(2^n)	Generate all possible subsequences and count distinct ones using recursion
Dynamic Programming with Character Tracking (Optimal)	O(n)	O(1)	Track the number of subsequences ending with each character to avoid duplicates

Generate All Subsequences — Algorithm Steps

Use recursion with two choices for each character: include it or skip it
Build subsequences character by character
Store all generated subsequences in a set to ensure uniqueness
Return the count of distinct subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty string

Begin recursion at index 0 with empty subsequence

Binary choice for each character

At each position, branch into include/exclude paths

Collect all leaf nodes

Non-empty subsequences at leaves are added to result set

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_SUBSEQ 100000

char subsequences[MAX_SUBSEQ][21];
int subseq_count = 0;

int contains_subsequence(const char* subseq) {
    for (int i = 0; i < subseq_count; i++) {
        if (strcmp(subsequences[i], subseq) == 0) {
            return 1;
        }
    }
    return 0;
}

void generate_subsequences(const char* s, int index, char* current, int curr_len) {
    if (index == strlen(s)) {
        if (curr_len > 0 && !contains_subsequence(current)) {
            strcpy(subsequences[subseq_count], current);
            subseq_count++;
        }
        return;
    }
    
    // Include current character
    current[curr_len] = s[index];
    current[curr_len + 1] = '\0';
    generate_subsequences(s, index + 1, current, curr_len + 1);
    
    // Exclude current character
    current[curr_len] = '\0';
    generate_subsequences(s, index + 1, current, curr_len);
}

int distinctSubseqII(char* s) {
    char current[21] = {0};
    subseq_count = 0;
    generate_subsequences(s, 0, current, 0);
    return subseq_count % MOD;
}

int main() {
    char s[21];
    scanf("%s", s);
    printf("%d\n", distinctSubseqII(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We have 2 choices for each of n characters, leading to 2^n possible subsequences

⚠ Quadratic Growth

Space Complexity

O(2^n)

We store all possible subsequences in a set, which can be up to 2^n subsequences

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase English letters only
Return the answer modulo 10⁹ + 7

28.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler