# Count number of substrings having at least K distinct characters

• Difficulty Level : Medium
• Last Updated : 06 Jun, 2021

Given a string S consisting of N characters and a positive integer K, the task is to count the number of substrings having at least K distinct characters.

Examples:

Input: S = “abcca”, K = 3
Output: 4
Explanation:
The substrings that contain at least K(= 3) distinct characters are:

1. “abc”: Count of distinct characters = 3.
2. “abcc”: Count of distinct characters = 3.
3. “abcca”: Count of distinct characters = 3.
4. “bcca”: Count of distinct characters = 3.

Therefore, the total count of substrings is 4.

Input: S = “abcca”, K = 4
Output: 0

Naive Approach: The simplest approach to solve the given problem is to generate all substrings of the given string and count those substrings that have at least K distinct characters in them. After checking for all the substrings, print the total count obtained as the result.

Time Complexity: O(N3)
Auxiliary Space: O(256)

Efficient Approach: The above approach can also be optimized by using the concept of Sliding Window and Hashing. Follow the steps below to solve the problem:

• Initialize a variable, say ans as 0 to store the count of substrings having at least K distinct characters.
• Initialize two pointers, begin and end to store the starting and ending point of the sliding window.
• Initialize a HashMap, say M to store the frequency of characters in the window.
• Iterate until end is less than N, and perform the following steps:
• Include the character at the end of the window, by incrementing the value of S[end] in M by 1.
• Iterate until the size of M becomes less than K, and perform the following steps:
• Remove the characters from the starting of the window by decrementing the value of S[begin] in M by 1.
• If its frequency becomes 0, then erase it from the map M.
• Count all the substrings starting from begin till N by incrementing ans by (N – end + 1).
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`` ` `#include ``using` `namespace` `std;`` ` `// Function to count number of substrings``// having atleast k distinct characters``void` `atleastkDistinctChars(string s, ``int` `k)``{``    ``// Stores the size of the string``    ``int` `n = s.size();`` ` `    ``// Initialize a HashMap``    ``unordered_map<``char``, ``int``> mp;`` ` `    ``// Stores the start and end``    ``// indices of sliding window``    ``int` `begin = 0, end = 0;`` ` `    ``// Stores the required result``    ``int` `ans = 0;`` ` `    ``// Iterate while the end``    ``// pointer is less than n``    ``while` `(end < n) {`` ` `        ``// Include the character at``        ``// the end of the window``        ``char` `c = s[end];``        ``mp++;`` ` `        ``// Increment end pointer by 1``        ``end++;`` ` `        ``// Iterate until count of distinct``        ``// characters becomes less than K``        ``while` `(mp.size() >= k) {`` ` `            ``// Remove the character from``            ``// the beginning of window``            ``char` `pre = s[begin];``            ``mp[pre]--;`` ` `            ``// If its frequency is 0,``            ``// remove it from the map``            ``if` `(mp[pre] == 0) {``                ``mp.erase(pre);``            ``}`` ` `            ``// Update the answer``            ``ans += s.length() - end + 1;``            ``begin++;``        ``}``    ``}`` ` `    ``// Print the result``    ``cout << ans;``}`` ` `// Driver Code``int` `main()``{``    ``string S = ``"abcca"``;``    ``int` `K = 3;``    ``atleastkDistinctChars(S, K);`` ` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{``   ` `// Function to count number of substrings``// having atleast k distinct characters``static` `void` `atleastkDistinctChars(String s, ``int` `k)``{``   ` `    ``// Stores the size of the string``    ``int` `n = s.length();`` ` `    ``// Initialize a HashMap``    ``Map mp = ``new` `HashMap<>();`` ` `    ``// Stores the start and end``    ``// indices of sliding window``    ``int` `begin = ``0``, end = ``0``;`` ` `    ``// Stores the required result``    ``int` `ans = ``0``;`` ` `    ``// Iterate while the end``    ``// pointer is less than n``    ``while` `(end < n) {`` ` `        ``// Include the character at``        ``// the end of the window``        ``char` `c = s.charAt(end);``        ``mp.put(c,mp.getOrDefault(c,``0``)+``1``);`` ` `        ``// Increment end pointer by 1``        ``end++;`` ` `        ``// Iterate until count of distinct``        ``// characters becomes less than K``        ``while` `(mp.size() >= k) {`` ` `            ``// Remove the character from``            ``// the beginning of window``            ``char` `pre = s.charAt(begin);``            ``mp.put(pre,mp.getOrDefault(pre,``0``)-``1``);`` ` `            ``// If its frequency is 0,``            ``// remove it from the map``            ``if` `(mp.get(pre)==``0``){``                ``mp.remove(pre);``            ``}`` ` `            ``// Update the answer``            ``ans += s.length() - end + ``1``;``            ``begin++;``        ``}``    ``}`` ` `    ``// Print the result``    ``System.out.println(ans);``}``   ` `  ``// Driver code``public` `static` `void` `main (String[] args) ``{``   ` `      ``// Given inputs``    ``String S = ``"abcca"``;``    ``int` `K = ``3``;``    ``atleastkDistinctChars(S, K);`` ` `    ``}``}`` ` `// This code is contributed by offbeat`

## Python3

 `# Python 3 program for the above approach``from` `collections ``import` `defaultdict`` ` `# Function to count number of substrings``# having atleast k distinct characters``def` `atleastkDistinctChars(s, k):`` ` `    ``# Stores the size of the string``    ``n ``=` `len``(s)`` ` `    ``# Initialize a HashMap``    ``mp ``=` `defaultdict(``int``)`` ` `    ``# Stores the start and end``    ``# indices of sliding window``    ``begin ``=` `0``    ``end ``=` `0`` ` `    ``# Stores the required result``    ``ans ``=` `0`` ` `    ``# Iterate while the end``    ``# pointer is less than n``    ``while` `(end < n):`` ` `        ``# Include the character at``        ``# the end of the window``        ``c ``=` `s[end]``        ``mp ``+``=` `1`` ` `        ``# Increment end pointer by 1``        ``end ``+``=` `1`` ` `        ``# Iterate until count of distinct``        ``# characters becomes less than K``        ``while` `(``len``(mp) >``=` `k):`` ` `            ``# Remove the character from``            ``# the beginning of window``            ``pre ``=` `s[begin]``            ``mp[pre] ``-``=` `1`` ` `            ``# If its frequency is 0,``            ``# remove it from the map``            ``if` `(mp[pre] ``=``=` `0``):``                ``del` `mp[pre]`` ` `            ``# Update the answer``            ``ans ``+``=` `len``(s) ``-` `end ``+` `1``            ``begin ``+``=` `1`` ` `    ``# Print the result``    ``print``(ans)`` ` ` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:`` ` `    ``S ``=` `"abcca"``    ``K ``=` `3``    ``atleastkDistinctChars(S, K)`` ` `    ``# This code is contributed by ukasp.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{``   ` `// Function to count number of substrings``// having atleast k distinct characters``static` `void` `atleastkDistinctChars(``string` `s, ``int` `k)``{``     ` `    ``// Stores the size of the string``    ``int` `n = s.Length;`` ` `    ``// Initialize a HashMap``    ``Dictionary<``char``,``               ``int``> mp = ``new` `Dictionary<``char``,``                                        ``int``>();`` ` `    ``// Stores the start and end``    ``// indices of sliding window``    ``int` `begin = 0, end = 0;`` ` `    ``// Stores the required result``    ``int` `ans = 0;`` ` `    ``// Iterate while the end``    ``// pointer is less than n``    ``while` `(end < n) ``    ``{``         ` `        ``// Include the character at``        ``// the end of the window``        ``char` `c = s[end];``        ``if` `(mp.ContainsKey(c))``            ``mp++;``        ``else``            ``mp.Add(c, 1);`` ` `        ``// Increment end pointer by 1``        ``end++;`` ` `        ``// Iterate until count of distinct``        ``// characters becomes less than K``        ``while` `(mp.Count >= k)``        ``{``             ` `            ``// Remove the character from``            ``// the beginning of window``            ``char` `pre = s[begin];``            ``mp[pre]--;`` ` `            ``// If its frequency is 0,``            ``// remove it from the map``            ``if` `(mp[pre] == 0) ``            ``{``                ``mp.Remove(pre);``            ``}`` ` `            ``// Update the answer``            ``ans += s.Length - end + 1;``            ``begin++;``        ``}``    ``}`` ` `    ``// Print the result``    ``Console.Write(ans);``}`` ` `// Driver Code``public` `static` `void` `Main()``{``    ``string` `S = ``"abcca"``;``    ``int` `K = 3;``     ` `    ``atleastkDistinctChars(S, K);``}``}`` ` `// This code is contributed by bgangwar59`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N)
Auxiliary Space: O(256)

My Personal Notes arrow_drop_up