Count the Number of Good Subsequences - Practice Coding Problems

Count the Number of Good Subsequences - Problem

A good subsequence is a fascinating string pattern where every character appears the same number of times! 🎯

Given a string s, you need to count how many non-empty subsequences have this special property where all characters have equal frequency. For example, in "abc", the subsequence "abc" is good because each character appears exactly once.

Remember: A subsequence maintains the original order but can skip characters. Since the result can be huge, return it modulo 10⁹ + 7.

Example: For s = "aab", good subsequences include "a" (appears twice), "b", and "ab" (both characters appear once).

Input & Output

example_1.py — Simple case

$ Input: s = "aab"

› Output: 6

💡 Note: Good subsequences: "a" (2 ways), "b" (1 way), "aa" (1 way), "ab" (2 ways). Total = 6 subsequences where all characters have equal frequency.

example_2.py — All same characters

$ Input: s = "aaa"

› Output: 7

💡 Note: Good subsequences: "a" (3 ways), "aa" (3 ways), "aaa" (1 way). Total = 7 subsequences.

example_3.py — All different characters

$ Input: s = "abc"

› Output: 7

💡 Note: Good subsequences: single chars "a", "b", "c" (3 ways), pairs "ab", "ac", "bc" (3 ways), triple "abc" (1 way). Total = 7.

Constraints

1 ≤ s.length ≤ 10⁴
s consists of lowercase English letters only
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Count Musicians

Count how many of each instrument type are available

Plan Group Sizes

For each possible group size k, check if we have enough of each instrument

Calculate Combinations

Use C(n,k) to count ways to select k musicians from n available of each type

Multiply Results

Multiply combinations across all instrument types to get total arrangements

Key Takeaway

🎯 Key Insight: Instead of generating all subsequences, we use combinatorial mathematics to count them directly by calculating C(frequency, target) for each character and multiplying the results.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 15

The optimal approach uses combinatorics to count good subsequences mathematically. First, count character frequencies, then for each possible target frequency k, calculate C(freq[char], k) for each character and multiply them together. This avoids generating actual subsequences and runs in O(n + k²) time where k is the maximum character frequency.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Combinatorics (Optimal)	O(n + k²)	O(1)	Use character frequencies and combinatorics to count good subsequences mathematically
Brute Force (Generate All Subsequences)	O(2^n × n)	O(n)	Generate every possible subsequence and check if character frequencies are equal

Dynamic Programming with Combinatorics (Optimal) — Algorithm Steps

Count frequency of each character in the string
For each possible target frequency k (1 to max frequency)
For each character, calculate C(freq[char], k) - ways to choose k occurrences
Multiply combinations for all characters to get subsequences with frequency k
Sum results for all valid frequencies

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each character appears in the string

Try Each Target

For each possible frequency k, calculate combinations

Calculate Ways

Multiply C(freq[c], k) for all characters to get total ways

Sum Results

Add up valid combinations for all frequencies

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 1000

long long modPow(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

long long modInverse(long long a) {
    return modPow(a, MOD - 2, MOD);
}

long long combination(int n, int r, long long* fact) {
    if (r > n || r < 0) return 0;
    if (r == 0 || r == n) return 1;
    
    long long num = fact[n];
    long long den = (fact[r] * fact[n - r]) % MOD;
    return (num * modInverse(den)) % MOD;
}

int countGoodSubsequences(char* s) {
    int n = strlen(s);
    
    // Count character frequencies
    int freq[256] = {0};
    for (int i = 0; i < n; i++) {
        freq[(unsigned char)s[i]]++;
    }
    
    // Find max frequency and collect frequencies
    int maxFreq = 0;
    int frequencies[256];
    int freqCount = 0;
    
    for (int i = 0; i < 256; i++) {
        if (freq[i] > 0) {
            frequencies[freqCount++] = freq[i];
            if (freq[i] > maxFreq) {
                maxFreq = freq[i];
            }
        }
    }
    
    if (freqCount == 0) return 0;
    
    // Precompute factorials
    long long fact[MAX_N + 1];
    fact[0] = 1;
    for (int i = 1; i <= maxFreq; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }
    
    long long total = 0;
    
    // Try each possible frequency k
    for (int k = 1; k <= maxFreq; k++) {
        long long ways = 1;
        int valid = 1;
        
        for (int i = 0; i < freqCount; i++) {
            if (frequencies[i] < k) {
                valid = 0;
                break;
            }
            ways = (ways * combination(frequencies[i], k, fact)) % MOD;
        }
        
        if (valid) {
            total = (total + ways) % MOD;
        }
    }
    
    return (int)total;
}

int main() {
    char s[MAX_N + 3];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        len = strlen(s);
        if (s[len-1] == '"') s[len-1] = '\0';
    }
    
    printf("%d\n", countGoodSubsequences(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k²)

O(n) to count frequencies, O(k²) for combinatorics where k is max frequency

✓ Linear Growth

Space Complexity

O(1)

Only storing character frequencies (at most 26 for lowercase letters)

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Combinatorics (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler