Related Articles
Longest substring where all the characters appear at least K times | Set 3
• Difficulty Level : Hard
• Last Updated : 29 Apr, 2021

Given a string str and an integer K, the task is to find the length of the longest substring S such that every character in S appears at least K times.

Examples:

Input: str = “aabbba”, K = 3
Output: 6
Explanation: In substring “aabbba”, each character repeats at least k times and its length is 6.

Input: str = “ababacb”, K = 3
Output: 0
Explanation: There is no substring where each character repeats at least k times.

Naive Approach: The simpelst approach to solve the given problem is discussed in Set 1
Time Complexity: O(N2)
Auxiliary Space: O(26)

Divide and Conquer Approach: The divide and conquer approach for the given problem is discussed in the Set 2
Time Complexity: O(N*log N)
Auxiliary Space: O(26)

Efficient Approach: The above two approaches can be optimized further by using Sliding Window technique. Follow the steps below to solve the problem:

• Store the number of unique characters in the string str in a variable, say unique.
• Initialize an array freq[] of size 26 with {0} and store the frequency of each character in this array.
• Iterate over the range [1, unique] using the variable curr_unique. In each iteration, curr_unique is the maximum number of unique characters that must be present in the window.
• Reinitialize the array freq[] with {0} to store the frequency of each character in this window.
• Initialize start and end as 0, to store the starting and the ending point of the window respectively.
• Use two variables cnt, for storing the number of unique characters and countK, for storing the number of characters with at least K repeating characters in the current window.
• Now, iterate a loop while end < N, and perform the following:
• If the value of cnt is less than or equals to curr_unique, then expand the window from the right by adding a character to the end of the window. And increment its frequency by 1 in freq[].
• Otherwise, reduce the window from the left by removing a character from start and decrementing its frequency by 1 in freq[].
• At every step, update the values of cnt and countK.
• If the value of cnt is same as curr_unique and each character occurs at least K times, then update the overall maximum length and store it in ans.
• 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 find the length of``// the longest substring``int` `longestSubstring(string s, ``int` `k)``{``    ``// Store the required answer``    ``int` `ans = 0;` `    ``// Create a frequency map of the``    ``// characters of the string``    ``int` `freq = { 0 };` `    ``// Store the length of the string``    ``int` `n = s.size();` `    ``// Traverse the string, s``    ``for` `(``int` `i = 0; i < n; i++)` `        ``// Increment the frequency of``        ``// the current character by 1``        ``freq[s[i] - ``'a'``]++;` `    ``// Stores count of unique characters``    ``int` `unique = 0;` `    ``// Find the number of unique``    ``// characters in string``    ``for` `(``int` `i = 0; i < 26; i++)``        ``if` `(freq[i] != 0)``            ``unique++;` `    ``// Iterate in range [1, unique]``    ``for` `(``int` `curr_unique = 1;``         ``curr_unique <= unique;``         ``curr_unique++) {` `        ``// Initialize frequency of all``        ``// characters as 0``        ``memset``(freq, 0, ``sizeof``(freq));` `        ``// Stores the start and the``        ``// end of the window``        ``int` `start = 0, end = 0;` `        ``// Stores the current number of``        ``// unique characters and characters``        ``// occuring atleast K times``        ``int` `cnt = 0, count_k = 0;` `        ``while` `(end < n) {``            ``if` `(cnt <= curr_unique) {``                ``int` `ind = s[end] - ``'a'``;` `                ``// New unique character``                ``if` `(freq[ind] == 0)``                    ``cnt++;` `                ``freq[ind]++;` `                ``// New character which``                ``// occurs atleast k times``                ``if` `(freq[ind] == k)``                    ``count_k++;` `                ``// Expand window by``                ``// incrementing end by 1``                ``end++;``            ``}``            ``else` `{``                ``int` `ind = s[start] - ``'a'``;` `                ``// Check if this character``                ``// is present atleast k times``                ``if` `(freq[ind] == k)``                    ``count_k--;` `                ``freq[ind]--;` `                ``// Check if this character``                ``// is unique``                ``if` `(freq[ind] == 0)``                    ``cnt--;` `                ``// Shrink the window by``                ``// incrementing start by 1``                ``start++;``            ``}` `            ``// If there are curr_unique``            ``// characters and each character``            ``// is atleast k times``            ``if` `(cnt == curr_unique``                ``&& count_k == curr_unique)` `                ``// Update the overall``                ``// maximum length``                ``ans = max(ans, end - start);``        ``}``    ``}` `    ``// Print the answer``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``string S = ``"aabbba"``;``    ``int` `K = 3;``    ``longestSubstring(S, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{` `// Function to find the length of``// the longest subString``static` `void` `longestSubString(``char``[] s, ``int` `k)``{``  ` `    ``// Store the required answer``    ``int` `ans = ``0``;` `    ``// Create a frequency map of the``    ``// characters of the String``    ``int` `freq[] = ``new` `int``[``26``];` `    ``// Store the length of the String``    ``int` `n = s.length;` `    ``// Traverse the String, s``    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``// Increment the frequency of``        ``// the current character by 1``        ``freq[s[i] - ``'a'``]++;` `    ``// Stores count of unique characters``    ``int` `unique = ``0``;` `    ``// Find the number of unique``    ``// characters in String``    ``for` `(``int` `i = ``0``; i < ``26``; i++)``        ``if` `(freq[i] != ``0``)``            ``unique++;` `    ``// Iterate in range [1, unique]``    ``for` `(``int` `curr_unique = ``1``;``         ``curr_unique <= unique;``         ``curr_unique++)``    ``{` `        ``// Initialize frequency of all``        ``// characters as 0``        ``Arrays.fill(freq, ``0``);` `        ``// Stores the start and the``        ``// end of the window``        ``int` `start = ``0``, end = ``0``;` `        ``// Stores the current number of``        ``// unique characters and characters``        ``// occuring atleast K times``        ``int` `cnt = ``0``, count_k = ``0``;``        ``while` `(end < n)``        ``{``            ``if` `(cnt <= curr_unique)``            ``{``                ``int` `ind = s[end] - ``'a'``;` `                ``// New unique character``                ``if` `(freq[ind] == ``0``)``                    ``cnt++;``                ``freq[ind]++;` `                ``// New character which``                ``// occurs atleast k times``                ``if` `(freq[ind] == k)``                    ``count_k++;` `                ``// Expand window by``                ``// incrementing end by 1``                ``end++;``            ``}``            ``else``            ``{``                ``int` `ind = s[start] - ``'a'``;` `                ``// Check if this character``                ``// is present atleast k times``                ``if` `(freq[ind] == k)``                    ``count_k--;``                ``freq[ind]--;` `                ``// Check if this character``                ``// is unique``                ``if` `(freq[ind] == ``0``)``                    ``cnt--;` `                ``// Shrink the window by``                ``// incrementing start by 1``                ``start++;``            ``}` `            ``// If there are curr_unique``            ``// characters and each character``            ``// is atleast k times``            ``if` `(cnt == curr_unique``                ``&& count_k == curr_unique)` `                ``// Update the overall``                ``// maximum length``                ``ans = Math.max(ans, end - start);``        ``}``    ``}` `    ``// Print the answer``    ``System.out.print(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String S = ``"aabbba"``;``    ``int` `K = ``3``;``    ``longestSubString(S.toCharArray(), K);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach` `# Function to find the length of``# the longest substring``def` `longestSubstring(s, k) :` `    ``# Store the required answer``    ``ans ``=` `0` `    ``# Create a frequency map of the``    ``# characters of the string``    ``freq ``=` `[``0``]``*``26` `    ``# Store the length of the string``    ``n ``=` `len``(s)` `    ``# Traverse the string, s``    ``for` `i ``in` `range``(n) :` `        ``# Increment the frequency of``        ``# the current character by 1``        ``freq[``ord``(s[i]) ``-` `ord``(``'a'``)] ``+``=` `1` `    ``# Stores count of unique characters``    ``unique ``=` `0` `    ``# Find the number of unique``    ``# characters in string``    ``for` `i ``in` `range``(``26``) :``        ``if` `(freq[i] !``=` `0``) :``            ``unique ``+``=` `1` `    ``# Iterate in range [1, unique]``    ``for` `curr_unique ``in` `range``(``1``, unique ``+` `1``) :` `        ``# Initialize frequency of all``        ``# characters as 0``        ``Freq ``=` `[``0``]``*``26` `        ``# Stores the start and the``        ``# end of the window``        ``start, end ``=` `0``, ``0` `        ``# Stores the current number of``        ``# unique characters and characters``        ``# occuring atleast K times``        ``cnt, count_k ``=` `0``, ``0` `        ``while` `(end < n) :``            ``if` `(cnt <``=` `curr_unique) :``                ``ind ``=` `ord``(s[end]) ``-` `ord``(``'a'``)` `                ``# New unique character``                ``if` `(Freq[ind] ``=``=` `0``) :``                    ``cnt ``+``=` `1` `                ``Freq[ind] ``+``=` `1` `                ``# New character which``                ``# occurs atleast k times``                ``if` `(Freq[ind] ``=``=` `k) :``                    ``count_k ``+``=` `1` `                ``# Expand window by``                ``# incrementing end by 1``                ``end ``+``=` `1``            ` `            ``else` `:``                ``ind ``=` `ord``(s[start]) ``-` `ord``(``'a'``)` `                ``# Check if this character``                ``# is present atleast k times``                ``if` `(Freq[ind] ``=``=` `k) :``                    ``count_k ``-``=` `1` `                ``Freq[ind] ``-``=` `1` `                ``# Check if this character``                ``# is unique``                ``if` `(Freq[ind] ``=``=` `0``) :``                    ``cnt ``-``=` `1` `                ``# Shrink the window by``                ``# incrementing start by 1``                ``start ``+``=` `1` `            ``# If there are curr_unique``            ``# characters and each character``            ``# is atleast k times``            ``if` `((cnt ``=``=` `curr_unique) ``and` `(count_k ``=``=` `curr_unique)) :` `                ``# Update the overall``                ``# maximum length``                ``ans ``=` `max``(ans, end ``-` `start)` `    ``# Print the answer``    ``print``(ans)` `S ``=` `"aabbba"``K ``=` `3``longestSubstring(S, K)` `# This code is contributed by divyesh072019.`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG``{``  ` `// Function to find the length of``// the longest substring``static` `void` `longestSubstring(``string` `s, ``int` `k)``{``  ` `    ``// Store the required answer``    ``int` `ans = 0;` `    ``// Create a frequency map of the``    ``// characters of the string``    ``int``[] freq = ``new` `int``;` `    ``// Store the length of the string``    ``int` `n = s.Length;` `    ``// Traverse the string, s``    ``for` `(``int` `i = 0; i < n; i++)` `        ``// Increment the frequency of``        ``// the current character by 1``        ``freq[s[i] - ``'a'``]++;` `    ``// Stores count of unique characters``    ``int` `unique = 0;` `    ``// Find the number of unique``    ``// characters in string``    ``for` `(``int` `i = 0; i < 26; i++)``        ``if` `(freq[i] != 0)``            ``unique++;` `    ``// Iterate in range [1, unique]``    ``for` `(``int` `curr_unique = 1;``         ``curr_unique <= unique;``         ``curr_unique++)``    ``{` `        ``// Initialize frequency of all``        ``// characters as 0``        ``for` `(``int` `i = 0; i < freq.Length; i++)``        ``{``            ``freq[i] = 0;``        ``}``        ` `        ``// Stores the start and the``        ``// end of the window``        ``int` `start = 0, end = 0;` `        ``// Stores the current number of``        ``// unique characters and characters``        ``// occuring atleast K times``        ``int` `cnt = 0, count_k = 0;``        ``while` `(end < n)``        ``{``            ``if` `(cnt <= curr_unique)``            ``{``                ``int` `ind = s[end] - ``'a'``;` `                ``// New unique character``                ``if` `(freq[ind] == 0)``                    ``cnt++;``                ``freq[ind]++;` `                ``// New character which``                ``// occurs atleast k times``                ``if` `(freq[ind] == k)``                    ``count_k++;` `                ``// Expand window by``                ``// incrementing end by 1``                ``end++;``            ``}``            ``else``            ``{``                ``int` `ind = s[start] - ``'a'``;` `                ``// Check if this character``                ``// is present atleast k times``                ``if` `(freq[ind] == k)``                    ``count_k--;``                ``freq[ind]--;` `                ``// Check if this character``                ``// is unique``                ``if` `(freq[ind] == 0)``                    ``cnt--;` `                ``// Shrink the window by``                ``// incrementing start by 1``                ``start++;``            ``}` `            ``// If there are curr_unique``            ``// characters and each character``            ``// is atleast k times``            ``if` `(cnt == curr_unique``                ``&& count_k == curr_unique)` `                ``// Update the overall``                ``// maximum length``                ``ans = Math.Max(ans, end - start);``        ``}``    ``}` `    ``// Print the answer``    ``Console.Write(ans);``}` `// Driver Code``public` `static` `void` `Main()``{``   ``string` `S = ``"aabbba"``;``    ``int` `K = 3;``    ``longestSubstring(S, K);``}``}` `// This code is contributed by splevel62.`

## Javascript

 ``

Output:
`6`

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

My Personal Notes arrow_drop_up