Find the Longest Substring Having K Distinct Vowels in Java

Our primary focus is on the set of vowels because the set of vowels is usually essential to many string manipulation problems, and one such problem is the problem of identifying the longest substring of the given string containing precisely K different vowels. The problem requires a good understanding of the working of string handling, sliding windows and use of hash maps.

Problem Statement

Enumerated string s and integer K are input data of the problem; the task is to determine the maximal length of substring including exactly K different vowels. If there is no such a word as string, then return 0.

Approach 1: Brute-Force Method

The method of using brute force is rather effective, though highly unproductive. It comprises testing all the potential sub-strings of the given string, making a count of the total though different vowels found in the sub-string. In case a substring comprises exactly K unique vowel(s), its size is compared to the previous maximum substring's size.

File Name: LongestKDistinctVowels.java

 
import java.util.HashSet;
import java.util.Set;
public class LongestKDistinctVowels {
    // Method to find the longest substring with exactly K distinct vowels
    public static int longestSubstringWithKDistinctVowels(String s, int K) {
        int maxLength = 0;
        // Iterate over each starting point of the substring
        for (int i = 0; i < s.length(); i++) {
            Set<Character> vowels = new HashSet<>();  // Set to track distinct vowels
            // Iterate over each ending point of the substring
            for (int j = i; j < s.length(); j++) {
                char ch = s.charAt(j);
                // Check if the current character is a vowel
                if (isVowel(ch)) {
                    vowels.add(ch);  // Add the vowel to the set
                }
                // If the set contains exactly K distinct vowels, update maxLength
                if (vowels.size() == K) {
                    maxLength = Math.max(maxLength, j - i + 1);
                }
            }
        }
        return maxLength;  
    }
    private static boolean isVowel(char ch) {
        return "aeiouAEIOU".indexOf(ch) != -1;
    }
    public static void main(String[] args) {
        String s = "aeiouxxaeiouu";
        int K = 2;
        System.out.println("Longest substring length with " + K + " distinct vowels: " + longestSubstringWithKDistinctVowels(s, K));
    }
}   

Output:

 
Longest substring length with 2 distinct vowels: 4

Time Complexity: O(N^3)

Space Complexity: O(K)

Approach 2: Optimized Sliding Window Approach

Optimized Sliding Window Approach Here, the algorithm is modified a little where we store the largest n values instead of just storing one value.

It is important to note that the brute force method is very time-consuming and recommended only for small strings. However, to improve, instead of just two for-loops, there is what is called the sliding window technique accompanied by a hash map where we have to keep track of the vowels in the current window.

Sliding Window with HashMap

The strategy is simply to slide the window wider until getting K different vowels, and then slide the window narrower to look for a larger valid window. We utilize a hash map to keep the current count of each vowel in the current window.

File Name: LongestKDistinctVowelsOptimized.java

 
import java.util.HashMap;
import java.util.Map;
public class LongestKDistinctVowelsOptimized {
    // Method to find the longest substring with exactly K distinct vowels using a sliding window
    public static int longestSubstringWithKDistinctVowels(String s, int K) {
        int maxLength = 0;
        Map<Character, Integer> vowelCountMap = new HashMap<>();  // HashMap to track the count of each vowel in the window
        int left = 0;  // Left boundary of the sliding window
        // Iterate over each character in the string as the right boundary of the window
        for (int right = 0; right < s.length(); right++) {
            char ch = s.charAt(right);
            // If the current character is a vowel, update its count in the map
            if (isVowel(ch)) {
                vowelCountMap.put(ch, vowelCountMap.getOrDefault(ch, 0) + 1);
            }
            // If there are more than K distinct vowels, shrink the window from the left
            while (vowelCountMap.size() > K) {
                char leftChar = s.charAt(left);
                if (isVowel(leftChar)) {
                    vowelCountMap.put(leftChar, vowelCountMap.get(leftChar) - 1);
                    if (vowelCountMap.get(leftChar) == 0) {
                        vowelCountMap.remove(leftChar);
                    }
                }
                left++;  // Move the left boundary to the right
            }
            // If there are exactly K distinct vowels, update maxLength
            if (vowelCountMap.size() == K) {
                maxLength = Math.max(maxLength, right - left + 1);
            }
        }
        return maxLength;  // Return the maximum length found
    }
    private static boolean isVowel(char ch) {
        return "aeiouAEIOU".indexOf(ch) != -1;
    }
    public static void main(String[] args) {
        String s = "aeiouxxaeiouu";
        int K = 2;
        System.out.println("Longest substring length with " + K + " distinct vowels: " + longestSubstringWithKDistinctVowels(s, K));
    }
}   

Output:

 
Longest substring length with 2 distinct vowels: 4

Time Complexity: O(N)

Space Complexity: O(K)

Conclusion

The problem of determining the longest substring with K distinct vowels can be solved in different ways, which makes the problem quite engaging. The said solution is simple but not scalable for large inputs because of the high time complexity required for computations.

The second solution is the sliding window technique with the help of a hash map, improving the result and being able to work with more significant strings. Which of the two methods to use depends on the problem and its solution, as well as the time allowed for their implementation in competitive programming and practical situations.

Next TopicImage-processing-in-java-comparison-of-two-images

← prev next →