Skip to content
Related Articles

Related Articles

Length of the smallest sub-string consisting of maximum distinct characters
  • Difficulty Level : Hard
  • Last Updated : 30 Apr, 2021

Given a string of length N, find the length of the smallest sub-string consisting of maximum distinct characters. Note : Our output can have same character. 

Examples: 

Input : "AABBBCBB"
Output : 5

Input : "AABBBCBBAC"
Output : 3
Explanation : Sub-string -> "BAC"

Input : "GEEKSGEEKSFOR"
Output : 8
Explanation : Sub-string -> "GEEKSFOR"

 Method 1 (Brute Force)

We can consider all sub-strings one by one and check for each sub-string both conditions together 
1. sub-string’s distinct characters is equal to maximum distinct characters 
2. sub-sting’s length should be minimum. 



Time Complexity : O(n^3) 

C++




/* C++ program to find the length of the smallest
substring consisting of maximum distinct characters */
#include <bits/stdc++.h>
using namespace std;
 
#define NO_OF_CHARS 256
 
// Find maximum distinct characters in any string
int max_distinct_char(string str, int n){
 
    // Initialize all character's count with 0
    int count[NO_OF_CHARS] = {0};
     
    // Increase the count in array if a character
    // is found
    for (int i = 0; i < n;  i++)
        count[str[i]]++;
     
    int max_distinct = 0;
    for (int i = 0; i < NO_OF_CHARS;  i++)
        if (count[i] != 0)     
            max_distinct++;    
     
    return max_distinct;
}
 
int smallesteSubstr_maxDistictChar(string str){
 
    int n = str.size();     // size of given string
 
    // Find maximum distinct characters in any string
    int max_distinct = max_distinct_char(str, n);
    int minl = n;   // result
     
    // Brute force approach to find all substrings
    for (int i=0 ;i<n ;i++){
        for (int j=0; j<n; j++){
            string subs =  str.substr(i,j);
            int subs_lenght = subs.size();
            int sub_distinct_char = max_distinct_char(subs, subs_lenght);
             
            // We have to check here both conditions together
            // 1. substring's distinct characters is equal
            //    to maximum distinct characters
            // 2. substing's length should be minimum
            if (subs_lenght < minl && max_distinct == sub_distinct_char){
                minl = subs_lenght;
            }
        }
    }
    return minl;
}
 
/* Driver program to test above function */
int main()
{
    // Input String
    string str = "AABBBCBB";
     
    int len =  smallesteSubstr_maxDistictChar(str);
    cout << " The length of the smallest substring"
            " consisting of maximum distinct "
            "characters : " << len;
    return 0;
}

Java




/* Java program to find the length of the smallest
substring consisting of maximum distinct characters */
class GFG {
 
    final static int NO_OF_CHARS = 256;
 
// Find maximum distinct characters in any string
    static int max_distinct_char(String str, int n) {
 
        // Initialize all character's count with 0
        int count[] = new int[NO_OF_CHARS];
 
        // Increase the count in array if a character
        // is found
        for (int i = 0; i < n; i++) {
            count[str.charAt(i)]++;
        }
 
        int max_distinct = 0;
        for (int i = 0; i < NO_OF_CHARS; i++) {
            if (count[i] != 0) {
                max_distinct++;
            }
        }
 
        return max_distinct;
    }
 
    static int smallesteSubstr_maxDistictChar(String str) {
 
        int n = str.length();     // size of given string
 
        // Find maximum distinct characters in any string
        int max_distinct = max_distinct_char(str, n);
        int minl = n;   // result
 
        // Brute force approach to find all substrings
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                 
                String subs = null;
                if(i<j)
                    subs = str.substring(i, j);
                else
                    subs = str.substring(j, i);
                int subs_lenght = subs.length();
                int sub_distinct_char = max_distinct_char(subs, subs_lenght);
 
                // We have to check here both conditions together
                // 1. substring's distinct characters is equal
                //    to maximum distinct characters
                // 2. substing's length should be minimum
                if (subs_lenght < minl && max_distinct == sub_distinct_char) {
                    minl = subs_lenght;
                }
            }
        }
        return minl;
    }
 
    /* Driver program to test above function */
    static public void main(String[] args) {
        // Input String
        String str = "AABBBCBB";
 
        int len = smallesteSubstr_maxDistictChar(str);
        System.out.println(" The length of the smallest substring"
                + " consisting of maximum distinct "
                + "characters : "+len);
    }
}
 
// This code is contributed by 29AjayKumar

Python3




# Python 3 program to find the length
# of the smallest substring consisting
# of maximum distinct characters
NO_OF_CHARS = 256
 
# Find maximum distinct characters
# in any string
def max_distinct_char(str, n):
 
    # Initialize all character's
    # count with 0
    count = [0] * NO_OF_CHARS
     
    # Increase the count in array
    # if a character is found
    for i in range(n):
        count[ord(str[i])] += 1
     
    max_distinct = 0
    for i in range(NO_OF_CHARS):
        if (count[i] != 0):
            max_distinct += 1   
     
    return max_distinct
 
def smallesteSubstr_maxDistictChar(str):
 
    n = len(str)     # size of given string
 
    # Find maximum distinct characters
    # in any string
    max_distinct = max_distinct_char(str, n)
    minl = n     # result
     
    # Brute force approach to
    # find all substrings
    for i in range(n):
        for j in range(n):
            subs = str[i:j]
            subs_lenght = len(subs)
            sub_distinct_char = max_distinct_char(subs,
                                                  subs_lenght)
             
            # We have to check here both conditions together
            # 1. substring's distinct characters is equal
            # to maximum distinct characters
            # 2. substing's length should be minimum
            if (subs_lenght < minl and
                max_distinct == sub_distinct_char):
                minl = subs_lenght
 
    return minl
 
# Driver Code
if __name__ == "__main__":
     
    # Input String
    str = "AABBBCBB"
     
    l = smallesteSubstr_maxDistictChar(str);
    print( "The length of the smallest substring",
           "consisting of maximum distinct",
           "characters :", l)
 
# This code is contributed by ChitraNayal

C#




/* C# program to find the length of the smallest
substring consisting of maximum distinct characters */
using System;
     
class GFG
{
 
    static int NO_OF_CHARS = 256;
 
    // Find maximum distinct characters in any string
    static int max_distinct_char(String str, int n)
    {
 
        // Initialize all character's count with 0
        int []count = new int[NO_OF_CHARS];
 
        // Increase the count in array if a character
        // is found
        for (int i = 0; i < n; i++)
        {
            count[str[i]]++;
        }
 
        int max_distinct = 0;
        for (int i = 0; i < NO_OF_CHARS; i++)
        {
            if (count[i] != 0)
            {
                max_distinct++;
            }
        }
 
        return max_distinct;
    }
 
    static int smallesteSubstr_maxDistictChar(String str)
    {
 
        int n = str.Length;     // size of given string
 
        // Find maximum distinct characters in any string
        int max_distinct = max_distinct_char(str, n);
        int minl = n; // result
 
        // Brute force approach to find all substrings
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                 
                String subs = null;
                if(i < j)
                    subs = str.Substring(i, str.Length-j);
                else
                    subs = str.Substring(j, str.Length-i);
                int subs_lenght = subs.Length;
                int sub_distinct_char = max_distinct_char(subs, subs_lenght);
 
                // We have to check here both conditions together
                // 1. substring's distinct characters is equal
                // to maximum distinct characters
                // 2. substing's length should be minimum
                if (subs_lenght < minl && max_distinct == sub_distinct_char)
                {
                    minl = subs_lenght;
                }
            }
        }
        return minl;
    }
 
    /* Driver program to test above function */
    static public void Main(String[] args)
    {
        // Input String
        String str = "AABBBCBB";
 
        int len = smallesteSubstr_maxDistictChar(str);
        Console.WriteLine(" The length of the smallest substring"
                + " consisting of maximum distinct "
                + "characters : "+len);
    }
}
 
// This code contributed by Rajput-Ji

PHP




<?php
/* PHP program to find the length of the smallest
substring consisting of maximum distinct characters */
 
$NO_OF_CHARS=256;
 
// Find maximum distinct characters in any string
function max_distinct_char($str, $n)
{
    global $NO_OF_CHARS;
     
    // Initialize all character's count with 0
    $count = array_fill(0, $NO_OF_CHARS, 0);
     
    // Increase the count in array if a character
    // is found
    for ($i = 0; $i < $n; $i++)
        $count[ord($str[$i])]++;
     
    $max_distinct = 0;
    for ($i = 0; $i < $NO_OF_CHARS; $i++)
        if ($count[$i] != 0)    
            $max_distinct++;    
     
    return $max_distinct;
}
 
function smallesteSubstr_maxDistictChar($str)
{
 
    $n = strlen($str); // size of given string
 
    // Find maximum distinct characters in any string
    $max_distinct = max_distinct_char($str, $n);
    $minl = $n; // result
     
    // Brute force approach to find all substrings
    for ($i = 0 ; $i < $n ; $i++)
    {
        for ($j = 0; $j < $n; $j++)
        {
            $subs = substr($str, $i, $j);
            $subs_lenght = strlen($subs);
            $sub_distinct_char = max_distinct_char($subs, $subs_lenght);
             
            // We have to check here both conditions together
            // 1. substring's distinct characters is equal
            // to maximum distinct characters
            // 2. substing's length should be minimum
            if ($subs_lenght < $minl &&
                $max_distinct == $sub_distinct_char)
            {
                $minl = $subs_lenght;
            }
        }
    }
    return $minl;
}
 
/* Driver code */
 
    // Input String
    $str = "AABBBCBB";
     
    $len = smallesteSubstr_maxDistictChar($str);
    echo " The length of the smallest substring"
            ." consisting of maximum distinct characters : ".$len;
 
// This coe is contributed by mits
?>

Javascript




<script>
 
// Javascript program to find the length
// of the smallest substring consisting
// of maximum distinct characters
let NO_OF_CHARS = 256;
 
// Find maximum distinct characters
// in any string
function max_distinct_char(str, n)
{
     
    // Initialize all character's
    // count with 0
    let count = new Array(NO_OF_CHARS);
    for(let i = 0; i < count.length; i++)
    {
        count[i] = 0;
    }
 
    // Increase the count in array if a
    // character is found
    for(let i = 0; i < n; i++)
    {
        count[str[i].charCodeAt(0)]++;
    }
 
    let max_distinct = 0;
    for(let i = 0; i < NO_OF_CHARS; i++)
    {
        if (count[i] != 0)
        {
            max_distinct++;
        }
    }
    return max_distinct;
}
 
function smallesteSubstr_maxDistictChar(str)
{
     
    // Size of given string
    let n = str.length;   
 
    // Find maximum distinct characters
    // in any string
    let max_distinct = max_distinct_char(str, n);
     
    // Result
    let minl = n;  
 
    // Brute force approach to find all
    // substrings
    for(let i = 0; i < n; i++)
    {
        for(let j = 0; j < n; j++)
        {
            let subs = null;
             
            if (i < j)
                subs = str.substring(i, j);
            else
                subs = str.substring(j, i);
                 
            let subs_lenght = subs.length;
            let sub_distinct_char = max_distinct_char(
                subs, subs_lenght);
 
            // We have to check here both conditions together
            // 1. substring's distinct characters is equal
            //    to maximum distinct characters
            // 2. substing's length should be minimum
            if (subs_lenght < minl &&
                max_distinct == sub_distinct_char)
            {
                minl = subs_lenght;
            }
        }
    }
    return minl;
}
 
// Driver Code
let str = "AABBBCBB";
let len = smallesteSubstr_maxDistictChar(str);
 
document.write("The length of the smallest substring" +
               " consisting of maximum distinct " +
               "characters : " + len);
 
// This code is contributed by avanitrachhadiya2155
     
</script>

Output: 

 The length of the smallest substring consisting
 of maximum distinct characters : 5

Method 2 (Efficient) 

  1. Count all distinct characters in given string.
  2. Maintain a window of characters. Whenever the window contains all characters of given string, we shrink the window from left side to remove extra characters and then compare its length with smallest window fount so far.

Please refer Smallest window that contains all characters of string itself for implementation and more details.
Asked In : DailyHunt 

This article is contributed by Harshit Agrawal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes arrow_drop_up
Recommended Articles
Page :