Minimum K such that every substring of length at least K contains a character c | Set-2

Given a string S consisting of N lowercase English alphabets, and also given that a character C is called K-amazing, if every substring of length at least K contains this character C, the task is to find the minimum possible K such that there exists at least one K-amazing character.

Examples:

Input: S = “abcde” 
Output: 3 
Explanation: 
Every, substring of length at least 3, has one K-amazing character, 'c': {“abc”, “bcd”, “cde”, “abcd”, “bcde”, “abcde”}. 

Input: S = “aaaa” 
Output: 1
Explanation: 
Every, substring of length at least 1, has one K-amazing character, 'a': {“a”, “aa”, “aaa”, “aaaa”}. 

For Naive and Binary Search approach, refer Set 1

Approach: The naive approach can be optimized based on the observation that for a character 'C' to exist in every substring of length K, the distance between positions of two consecutive 'C' cannot exceed K. Follow the steps below to solve the problem:

• Initialize an integer variable, say ans as N, which will store the minimum size of the substring possible such that every substring of size ans has at least one K-amazing character.
• Insert the character '0' to the front and end of the string S.
• Iterate over the characters in the range [a, z] using the variable c and perform the following steps:
  • Assign character c to S[0] and S[N+1].
  • Initialize two variables, say prev as 0 and maxLen as 0, where prev will store the last index of the character c and maxLen will store the maximum distance between the positions of the two nearest c.
  • Iterate over the range [1, N+1] using the variable i and perform the following steps:
    • If S[i] = c, then modify the value of maxLen  to max(maxLen, i - prev) and then assign i to prev.
  • Now modify the value of ans to min(ans, max_len).
• Finally, after completing the above steps, print the value of ans obtained.

Below is the implementation of the above approach:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find minimum value of K
// such that there exist atleast one K
// amazing character

int MinimumLengthSubstring(string S, int N)
{
    // Stores the answer
    int ans = N;

    // Update the string S
    S = "0" + S + "0";

    // Iterate over the characters
    // in range [a, z]
    for (char c = 'a'; c <= 'z'; ++c) {

        // Stores the last index where
        // c appears
        int prev = 0;

        // Stores the maximum possible length
        int max_len = 0;

        // Update string S
        S[0] = c;
        S[N + 1] = c;

        // Iterate over characters of string
        // S
        for (int i = 1; i <= N + 1; ++i) {
            // If S[i] is equal to c
            if (S[i] == c) {

                // Stores the distance between
                // positions of two same c
                int len = i - prev;

                // Update max_len
                max_len = max(max_len, len);

                // Update the value of prev
                prev = i;
            }
        }

        // Update the value of ans
        ans = min(ans, max_len);
    }

    // Return the answer
    return ans;
}

// Driver Code
int main()
{
    // Given Input
    string S = "abcde";
    int N = S.length();

    // Function Call
    cout << MinimumLengthSubstring(S, N);
}

import java.util.*;

public class Main {

    // Function to find minimum value of K
    // such that there exist atleast one K
    // amazing character
    static int MinimumLengthSubstring(String S, int N)
    {

        // Stores the answer
        int ans = N;

        // Update the string S
        S = "0" + S + "0";

        // Iterate over the characters
        // in range [a, z]
        for (char c = 'a'; c <= 'z'; ++c) {

            // Stores the last index where
            // c appears
            int prev = 0;

            // Stores the maximum possible length
            int max_len = 0;

            // Update string S
            S = c + S.substring(1, S.length() - 1) + c;

            // Iterate over characters of string
            // S
            for (int i = 1; i <= N + 1; ++i) {
                // If S[i] is equal to c
                if (S.charAt(i) == c) {

                    // Stores the distance between
                    // positions of two same c
                    int len = i - prev;

                    // Update max_len
                    max_len = Math.max(max_len, len);

                    // Update the value of prev
                    prev = i;
                }
            }

            // Update the value of ans
            ans = Math.min(ans, max_len);
        }

        // Return the answer
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given Input
        String S = "abcde";
        int N = S.length();

        // Function Call
        System.out.println(MinimumLengthSubstring(S, N));
    }
}
// This code is contributed by NarasingaNikhil

# Python3 program for the above approach

# Function to find minimum value of K
# such that there exist atleast one K
# amazing character
def MinimumLengthSubstring(S, N):
    
    # Stores the answer
    ans = N

    # Update the S
    S = "0" + S + "0"
    S = [i for i in S]

    # Iterate over the characters
    # in range [a, z]
    for c in range(ord('a'), ord('z') + 1):
        
        # Stores the last index where
        # c appears
        prev = 0

        # Stores the maximum possible length
        max_len = 0

        # Update S
        S[0] = chr(c)
        S[N + 1] = chr(c)

        # Iterate over characters of string
        # S
        for i in range(1, N + 2):
            
            # If S[i] is equal to c
            if (S[i] == chr(c)):
                
                # Stores the distance between
                # positions of two same c
                len = i - prev

                # Update max_len
                max_len = max(max_len, len)

                # Update the value of prev
                prev = i

        # Update the value of ans
        ans = min(ans, max_len)

    # Return the answer
    return ans

# Driver Code
if __name__ == '__main__':
    
    # Given Input
    S = "abcde"
    N = len(S)

    # Function Call
    print(MinimumLengthSubstring(S, N))

# This code is contributed by mohit kumar 29

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to find minimum value of K
// such that there exist atleast one K
// amazing character

static int MinimumLengthSubstring(string S, int N)
{
    // Stores the answer
    int ans = N;

    // Update the string S
    S = "0" + S + "0";

    // Iterate over the characters
    // in range [a, z]
    for (char c = 'a'; c <= 'z'; ++c) {

        // Stores the last index where
        // c appears
        int prev = 0;

        // Stores the maximum possible length
        int max_len = 0;

        // Update string S
       S = S.Substring(0,0) + c + S.Substring(1);
       S = S.Substring(0, N+1) + c + S.Substring(N + 2);

        // Iterate over characters of string
        // S
        for (int i = 1; i <= N + 1; ++i) {
            // If S[i] is equal to c
            if (S[i] == c) {

                // Stores the distance between
                // positions of two same c
                int len = i - prev;

                // Update max_len
                max_len = Math.Max(max_len, len);

                // Update the value of prev
                prev = i;
            }
        }

        // Update the value of ans
        ans = Math.Min(ans, max_len);
    }

    // Return the answer
    return ans;
}

// Driver Code
public static void Main()
{
    // Given Input
    string S = "abcde";
    int N = S.Length;

    // Function Call
    Console.Write(MinimumLengthSubstring(S, N));
}
}

// This code is contributed by SURENDRA_GANGWAR.

// JavaScript program for the above approach


// Function to find minimum value of K
// such that there exist atleast one K
// amazing character

function MinimumLengthSubstring(S, N) {
    // Stores the answer
    let ans = N;

    // Update the string S
    S = "0" + S + "0";
    S = S.split("")

    // Iterate over the characters
    // in range [a, z]
    for (let c = 'a'.charCodeAt(0); c <= 'z'.charCodeAt(0); ++c) {

        // Stores the last index where
        // c appears
        let prev = 0;

        // Stores the maximum possible length
        let max_len = 0;

        // Update string S
        S[0] = String.fromCharCode(c);
        S[N + 1] = String.fromCharCode(c);

        // Iterate over characters of string
        // S
        for (let i = 1; i <= N + 1; ++i) {
            // If S[i] is equal to c
            if (S[i] == String.fromCharCode(c)) {

                // Stores the distance between
                // positions of two same c
                let len = i - prev;

                // Update max_len
                max_len = Math.max(max_len, len);

                // Update the value of prev
                prev = i;
            }
        }

        // Update the value of ans
        ans = Math.min(ans, max_len);
    }

    // Return the answer
    return ans;
}




// Driver Code

// Given Input
let S = "abcde";
let N = S.length;

// Function Call
console.log(MinimumLengthSubstring(S, N));

3

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

ujjwalgoel1103

Follow

Improve

Article Tags :

• Strings
• Competitive Programming
• DSA
• substring

Practice Tags :

• Strings