Count Substrings With K-Frequency Characters II

Count Substrings With K-Frequency Characters II - Problem

Imagine you're analyzing text patterns in a document search engine. You need to find all possible substrings where at least one character appears frequently enough to be considered "significant".

Given a string s and an integer k, your task is to count the total number of substrings where at least one character appears at least k times within that substring.

A substring is a contiguous sequence of characters within a string. For example, in the string "abc", the substrings are: "a", "b", "c", "ab", "bc", and "abc".

Goal: Return the count of all valid substrings that contain at least one character with frequency ≥ k.

Input & Output

example_1.py — Basic Case

$ Input: s = "aaabbc", k = 3

› Output: 3

💡 Note: Valid substrings are: "aaa" (a appears 3 times), "aaab" (a appears 3 times), "aaabb" (a appears 3 times). All other substrings have no character appearing 3 or more times.

example_2.py — No Valid Substrings

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

› Output: 0

💡 Note: No substring has any character appearing 2 or more times since all characters are unique.

example_3.py — All Substrings Valid

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

› Output: 6

💡 Note: All 6 possible substrings ("a", "a", "a", "aa", "aa", "aaa") contain at least one character that appears ≥ 1 times.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ k ≤ s.length
s consists of only lowercase English letters
The answer will fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Calculate Total

Find total possible substrings: n*(n+1)/2

Track Invalid

Use sliding window to count substrings where max frequency < k

Expand Window

Add characters to window, update frequency counts

Contract When Needed

Shrink window when any character frequency reaches k

Subtract

Return total_substrings - invalid_substrings

Key Takeaway

🎯 Key Insight: Instead of checking each substring individually (O(n³)), we use complementary counting. By efficiently finding substrings where NO character appears k times using a sliding window, we solve the problem in optimal O(n) time.

Asked in

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

The optimal solution uses complementary counting with a sliding window approach. Instead of directly counting valid substrings (O(n³)), we count invalid substrings where no character appears ≥ k times, then subtract from total. The sliding window efficiently maintains character frequencies in O(n) time, making this approach much faster than brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and count character frequencies in each
Optimized Sliding Window (Optimal)	O(n)	O(1)	Use complementary counting: total substrings minus invalid substrings

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, create a frequency map of characters
Check if any character in the frequency map has count ≥ k
Increment result counter if condition is met
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Substrings

Use nested loops to create every possible substring

Count Character Frequencies

For each substring, count how many times each character appears

Check Condition

Verify if any character appears at least k times

Increment Counter

Add to result if condition is satisfied

Code -

solution.c — C

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

int countSubstrings(char* s, int k) {
    int n = strlen(s);
    int count = 0;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count frequency of each character in substring
            int freq[26] = {0};
            for (int l = i; l <= j; l++) {
                freq[s[l] - 'a']++;
            }
            
            // Check if any character appears at least k times
            int found = 0;
            for (int l = 0; l < 26; l++) {
                if (freq[l] >= k) {
                    found = 1;
                    break;
                }
            }
            if (found) count++;
        }
    }
    
    return count;
}

int main() {
    char s[1000];
    int k;
    scanf("%s %d", s, &k);
    printf("%d\n", countSubstrings(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings, O(n) for counting characters in each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a fixed-size frequency map for 26 lowercase letters

✓ Linear Space

42.0K Views

High Frequency

~25 min Avg. Time

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

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler