- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- Social Studies
- Fashion Studies
- Legal Studies

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

# Minimum K such that every substring of length at least K contains a character c

A string is given in this problem and we have to find a minimum length ‘k’ such that all the substrings of the given string of length k contains at least one common character. We will see three approaches for this problem, one the naive approach to find all the substrings, another one is the binary search approach and third is by using the minimum difference approach.

### Sample Example

string str = “efabc” Output: 3

### Explanation

For the substrings of length 1 and 2 it is not possible to contain the same character for example substring ‘ef’ and ‘bc’ does not have any same character. But for the substring of length 3 or more ‘a’ will always present there.

## Naive Approach

In this approach, we will generate all the substrings and for all of them we will check if any character is common or not, but this method will take very much time.

### Example

#include <bits/stdc++.h> using namespace std; // function to find the minimum length of the substring int minLen(string str){ int n = str.length(); // length of the given string // finding all the substrings fo the same length for(int len = 1; len <= n; len++){ int freq[26] = {0}; // frequency array to store the frequency for(int i=0; i<=n-len; i++){ int j = i+len; // ending of the current substring int cur[26] = {0}; for(int k = i; k<j; k++){ if(cur[str[k]-'a']){ continue; } // storing the frequecy of the letters freq[str[k]-'a']++; cur[str[k]-'a']++; } } // total number of substring with this length int scount = n-len+1; // if any character have the same frequecy then we will return current length for(int i=0; i<26; i++){ if(freq[i] == scount){ return len; } } } return n; } // main function int main(){ string str = "efabc"; // given string // calling the function cout<<"The minimum length of the substrings that contains at least a same character is "<<minLen(str)<<endl; return 0; }

### Output

The minimum length of the substrings that contains at least a same character is 3

**Time and Space Complexity**

The time complexity of the above code is O(N^3), where N is the size of the given string. The space complexity of the above code is O(1), as we are using the constant space.

## Binary Search

In this approach, we will use the binary search technique to find the minimum length substring. We will traverse over the substring for each character and will check what minimum length substring length will be required and use the binary search over the answer.

### Example

#include <bits/stdc++.h> using namespace std; // function to check last occurence bool check(int len, string str){ int n = str.length(); for(int i=0; i< 26; i++){ int last = -1; int cur = 'a'+i; int j; for(j=0; j < n; j++){ if(str[j] == cur){ if(j-len > last){ break; } else{ last = j; } } } if(j != n || j-len > last){ continue; } else{ return true; } } return false; } // function to find the minimum length of the substring int minLen(string str){ int n = str.length(); // length of the given string int l = 1, h = n; int ans; while (l <= h){ int len = (l + h) / 2; if (check(len, str)) { ans = len; h = len - 1; } else l = len + 1; } return ans; } // main function int main(){ string str = "aaabaaa"; // given string // calling the function cout<<"The minimum length of the substrings that contains at least a same character is "<<minLen(str)<<endl; return 0; }

### Output

The minimum length of the substrings that contains at least a same character is 2

**Time and Space Complexity**

The time complexity of the above code is O(N*log(N)), where N is the size of the given string. The space complexity of the above code is O(1), as we are using the constant space.

## Efficient Approach

In this approach, we have traversed over the string and for each lower case English alphabet character we have maintained the last occurrence and the gap between the each two same character, the starting and the ending of the given string.

### Example

#include <bits/stdc++.h> using namespace std; // function to find the minimum length of the substring int minLen(string str){ int last[26]; // array to store the last occurrence, of the characters memset(last,-1,sizeof(last)); // making start of each character equal to -1 int minLen[26]; // array to store minimum length of substring for each char // initializing to length of string int n = str.length(); for(int i=0; i<26; i++){ minLen[i] = -1; } // traversing over the string to get the answer int ans = n; for(int i=0; i<n; i++){ if(minLen[str[i]-'a'] == -1){ minLen[str[i]-'a'] = i+1; } else{ minLen[str[i]-'a'] = max(minLen[str[i]-'a'], i-last[str[i]-'a']); } last[str[i]-'a'] = i; } for(int i=0; i<26; i++){ minLen[i] = max(minLen[i], n-last[i]); ans = min(ans, minLen[i]); } return ans; } // main function int main(){ string str = "efabc"; // given string // calling the function cout<<"The minimum length of the substrings that contains at least a same character is "<<minLen(str)<<endl; return 0; }

### Output

The minimum length of the substrings that contains at least a same character is 3

**Time and Space Complexity**

The time complexity of the above code is O(N), which is the linear time complexity. The space complexity of the above code is O(1), as we are using the constant space.

## Conclusion

In this tutorial, we have implemented a code to find the minimum length of the substrings that contains at least a same character. We have implemented three approaches to find the solution. First approach, is the naive approach with very high time complexity. The second approach, is the binary search approach and the last one is efficient with linear time complexity.