Count the Number of Good Subsequences - Problem

A subsequence of a string is good if it is not empty and the frequency of each one of its characters is the same.

Given a string s, return the number of good subsequences of s. Since the answer may be too large, return it modulo 10^9 + 7.

A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

Input & Output

Example 1 — Basic Case

$ Input: s = "aab"

› Output: 6

💡 Note: Good subsequences: "a" (pos 0), "a" (pos 1), "b" (pos 2), "aa" (pos 0,1), "ab" (pos 0,2), "ab" (pos 1,2). All have equal character frequencies within each subsequence.

Example 2 — Single Character

$ Input: s = "aaaa"

› Output: 4

💡 Note: Good subsequences: "a", "aa", "aaa", "aaaa". Each has only character 'a' with frequencies 1, 2, 3, 4 respectively.

Example 3 — Mixed Characters

$ Input: s = "abc"

› Output: 3

💡 Note: Good subsequences: "a", "b", "c". Each single character has frequency 1. "ab", "ac", "bc", "abc" are not good because they have different character frequencies.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is to use combinatorics to count subsequences where all characters have equal frequency. Instead of generating all subsequences, we count character frequencies and calculate combinations mathematically. Time: O(n × max_freq²), Space: O(1).

Common Approaches

✓ Memoization

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

Dp 2d

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

Character Frequency Analysis

⏱️ Time: O(n × max_freq²) Space: O(26)

This approach counts the frequency of each character in the string, then uses mathematical combinations to determine how many subsequences have equal character frequencies without generating them explicitly.

Dynamic Programming with Memoization

⏱️ Time: O(n × prod(freq_i)) Space: O(n × prod(freq_i))

This approach uses dynamic programming with memoization to efficiently count subsequences. We maintain state for each character's usage count and use memoization to avoid recalculating the same states.

Generate All Subsequences

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

This approach generates every possible subsequence of the string and checks if all characters in each subsequence have the same frequency. We use bit manipulation to generate all 2^n subsequences.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 1001
#define OFFSET 1000

int memo[MAXN][4][2001];
int visited[MAXN][4][2001];

int getPoints(char aliceMove, char bobMove) {
    if (aliceMove == bobMove) return 0;
    if ((bobMove == 'F' && aliceMove == 'E') ||
        (bobMove == 'W' && aliceMove == 'F') ||
        (bobMove == 'E' && aliceMove == 'W')) {
        return 1; // Bob gets point
    }
    return -1; // Alice gets point
}

int charToInt(char c) {
    if (c == 'F') return 0;
    if (c == 'W') return 1;
    if (c == 'E') return 2;
    return 3; // none
}

int dp(const char* s, int pos, int lastMove, int scoreDiff, int n) {
    if (pos == n) {
        return scoreDiff > 0 ? 1 : 0;
    }
    
    int adjScoreDiff = scoreDiff + OFFSET;
    if (visited[pos][lastMove][adjScoreDiff]) {
        static return memo[pos][lastMove][adjScoreDiff];
    }
    
    int count = 0;
    char moves[] = {'F', 'W', 'E'};
    
    for (int i = 0; i < 3; i++) {
        char move = moves[i];
        int moveInt = charToInt(move);
        
        if (pos == 0 || moveInt != lastMove) {
            int points = getPoints(s[pos], move);
            int newScoreDiff = scoreDiff + points;
            count = (count + dp(s, pos + 1, moveInt, newScoreDiff, n)) % MOD;
        }
    }
    
    visited[pos][lastMove][adjScoreDiff] = 1;
    memo[pos][lastMove][adjScoreDiff] = count;
    return count;
}

int solution(const char* s) {
    int n = strlen(s);
    memset(visited, 0, sizeof(visited));
    return dp(s, 0, 3, 0, n);
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

234 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