Count K-Subsequences of a String With Maximum Beauty - Problem

You are given a string s and an integer k.

A k-subsequence is a subsequence of s, having length k, and all its characters are unique, i.e., every character occurs once.

Let f(c) denote the number of times the character c occurs in s.

The beauty of a k-subsequence is the sum of f(c) for every character c in the k-subsequence.

For example, consider s = "abbbdd" and k = 2:

f('a') = 1, f('b') = 3, f('d') = 2
Some k-subsequences of s are:
- "abbbdd" → "ab" having a beauty of f('a') + f('b') = 4
- "abbbdd" → "ad" having a beauty of f('a') + f('d') = 3
- "abbbdd" → "bd" having a beauty of f('b') + f('d') = 5

Return an integer denoting the number of k-subsequences whose beauty is the maximum among all k-subsequences. Since the answer may be too large, return it modulo 10^9 + 7.

Note: f(c) is the number of times a character c occurs in s, not a k-subsequence.

Input & Output

Example 1 — Basic Case

$ Input: s = "abbbdd", k = 2

› Output: 1

💡 Note: Characters: a(freq=1), b(freq=3), d(freq=2). For k=2, possible combinations are (a,b)→beauty=4, (a,d)→beauty=3, (b,d)→beauty=5. Maximum beauty is 5, achieved by 1 combination.

Example 2 — Multiple Ways

$ Input: s = "aabbcc", k = 2

› Output: 3

💡 Note: Each character appears twice. Any 2 characters give beauty=4. There are C(3,2)=3 ways to choose 2 from {a,b,c}.

Example 3 — Edge Case

$ Input: s = "abc", k = 1

› Output: 3

💡 Note: Each character appears once. Maximum beauty is 1, achieved by selecting any single character. 3 ways total.

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ k ≤ s.length
s consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15

The key insight is that maximum beauty comes from selecting the k characters with highest frequencies. The optimal approach uses greedy selection combined with combinatorics to handle tied frequencies efficiently. Best approach: O(n + m log m) time, O(m) space.

Common Approaches

✓ Optimized

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

Backtracking

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

Brute Force - Generate All K-Subsequences

⏱️ Time: O(C(n,k) × n) Space: O(n)

Try every combination of k unique characters from the string, calculate the beauty for each combination, and count how many achieve the maximum beauty.

Greedy with Combinatorics

⏱️ Time: O(n + m log m) Space: O(m)

Sort characters by frequency in descending order, greedily select the k highest frequency characters, and use combinatorial math to count the number of ways to form subsequences with maximum beauty.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_CHARS 26
#define MAX_COMBINATIONS 1000

int freq[MAX_CHARS];
char uniqueChars[MAX_CHARS];
int uniqueCount;
int combinations[MAX_COMBINATIONS][MAX_CHARS];
int combCount;

void generateCombinations(int k, int start, int currentCombo[], int currentSize) {
    if (currentSize == k) {
        for (int i = 0; i < k; i++) {
            combinations[combCount][i] = currentCombo[i];
        }
        combCount++;
        return;
    }
    
    for (int i = start; i < uniqueCount; i++) {
        currentCombo[currentSize] = i;
        generateCombinations(k, i + 1, currentCombo, currentSize + 1);
    }
}

int solution(const char* s, int k) {
    int len = strlen(s);
    
    // Initialize frequency array
    for (int i = 0; i < MAX_CHARS; i++) {
        freq[i] = 0;
    }
    
    // Count character frequencies
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Get unique characters
    uniqueCount = 0;
    for (int i = 0; i < MAX_CHARS; i++) {
        if (freq[i] > 0) {
            uniqueChars[uniqueCount] = 'a' + i;
            uniqueCount++;
        }
    }
    
    if (uniqueCount < k) {
        return 0;
    }
    
    // Generate combinations
    combCount = 0;
    int currentCombo[MAX_CHARS];
    generateCombinations(k, 0, currentCombo, 0);
    
    int maxBeauty = 0;
    int count = 0;
    
    for (int i = 0; i < combCount; i++) {
        int beauty = 0;
        for (int j = 0; j < k; j++) {
            int charIndex = combinations[i][j];
            beauty += freq[uniqueChars[charIndex] - 'a'];
        }
        
        if (beauty > maxBeauty) {
            maxBeauty = beauty;
            count = 1;
        } else if (beauty == maxBeauty) {
            count++;
        }
    }
    
    return count % MOD;
}

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

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

24.0K Views

Medium Frequency

~35 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