Distinct Subsequences II

Distinct Subsequences II - Problem

Given a string s, return the number of distinct non-empty subsequences of s. Since the answer may be very large, return it modulo 10^9 + 7.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).

Input & Output

Example 1 — Basic Case

$ Input: s = "abc"

› Output: 7

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

Example 2 — Duplicate Characters

$ Input: s = "aba"

› Output: 6

💡 Note: The distinct subsequences are: "a", "b", "aa", "ab", "ba", "aba". Note that "a" appears twice in the string but is counted only once as a single character subsequence. Total = 6.

Example 3 — All Same Characters

$ Input: s = "aaa"

› Output: 3

💡 Note: The distinct subsequences are: "a", "aa", "aaa". All single 'a' subsequences are the same. Total = 3.

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 M Microsoft 12

The key insight is to use dynamic programming to track subsequences ending with each character, avoiding duplicate counting. When we encounter a repeated character, we subtract the count from its previous occurrence. Best approach uses O(n) time and O(1) space.

Common Approaches

✓ Binary Search Answer

⏱️ Time: N/A Space: N/A

Dynamic Programming with Character Tracking

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

We maintain the total count of distinct subsequences seen so far. For each new character, we can either start a new subsequence with just that character, or append it to all existing subsequences. If we've seen the character before, we subtract the count from when we last saw it to avoid duplicates.

Generate All Subsequences

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

For each character, we have two choices: include it or exclude it. This creates 2^n possible subsequences. We generate all of them, store in a set to remove duplicates, then count.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007

int distinctSubseqII(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    int last[26];
    for (int i = 0; i < 26; i++) {
        last[i] = -1;
    }
    
    long long* dp = (long long*)malloc((n + 1) * sizeof(long long));
    dp[0] = 1;
    
    for (int i = 1; i <= n; i++) {
        int c = s[i-1] - 'a';
        dp[i] = (dp[i-1] * 2) % MOD;
        
        if (last[c] != -1) {
            dp[i] = (dp[i] - dp[last[c]] + MOD) % MOD;
        }
        
        last[c] = i - 1;
    }
    
    long long result = (dp[n] - 1 + MOD) % MOD;
    free(dp);
    return (int)result;
}

int main() {
    char s[1001];
    if (fgets(s, sizeof(s), stdin)) {
        s[strcspn(s, "\n")] = 0;
        printf("%d\n", distinctSubseqII(s));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K 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