Find the Longest Substring Consisting of Vowels Using Binary Search in Java

Identifying the longest string that contains only vowels given a string is one of the classic problems that can be solved in several ways. Straight forward way to solve the problem can be to shift through all possible substrings and compare, but it takes a lot of time when strings are large.

However, I have found a faster solution, which applies the binary search along with what is called the sliding window technique. This method decreases the time factor of the problem while at the same time making sure that we get the largest possible substring with all s different characters.

Problem Statement

The problem is to find the maximum size of a continuous sub-string of the given string containing only vowels. The seeming problem in this case is to determine the length of the substring that generates the highest score without necessarily considering all substrings. The Binary search shall also be suited for this problem as it helps to significantly narrow down the range of valid lengths for the fixed substring.

Approaches to Solve The Problem

Binary Search on Length:

We bring in the binary search to home into the maximum length of a substring comprised of vowels only. It involves setting a lower bound (left) as well as the upper bound, which gives the probable length of such substrings. The middle of this range (mid) is tested against whether a substring of that length can be built of only vowels. According to this check, the range of the search is controlled until the best length of the search is identified.

Sliding Window for Validation:

To find all the palindromic substrings of the midpoint length obtained from binary search, we employ the sliding window algorithm. It is a type of sliding window that traverses the string, and for every new character, it checks if the character is a vowel. When such a substring is found to comprise only vowels, then the search parameters are accordingly altered to increase the validity of the results.

 
public class LongestVowelSubstring {
    // Method to check if there is a substring of length 'len' consisting only of vowels
    private static boolean hasVowelSubstringOfLength(String s, int len) {
        int count = 0;        
        // Initial window check
        for (int i = 0; i < len; i++) {
            if (isVowel(s.charAt(i))) {
                count++;
            }
        }
        if (count == len) return true;        
        // Sliding window over the string
        for (int i = len; i < s.length(); i++) {
            if (isVowel(s.charAt(i))) {
                count++;
            }
            if (isVowel(s.charAt(i - len))) {
                count--;
            }
            if (count == len) return true;
        }        
        return false;
    }
    // Method to perform a binary search to find the maximum length of a vowel-only substring
    public static int longestVowelSubstring(String s) {
        int left = 1, right = s.length(), maxLength = 0;       
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (hasVowelSubstringOfLength(s, mid)) {
                maxLength = mid;
                left = mid + 1;  // Try for a longer length
            } else {
                right = mid - 1;  // Try for a shorter length
            }
        }        
        return maxLength;
    }
    private static boolean isVowel(char ch) {
        return "aeiouAEIOU".indexOf(ch) != -1;
    }
    public static void main(String[] args) {
        String s = "earthproblem";
        System.out.println("Longest substring length consisting of vowels: " + longestVowelSubstring(s));  // Expected output: 2        
        s = "letsgosomewhere";
        System.out.println("Longest substring length consisting of vowels: " + longestVowelSubstring(s));  // Expected output: 3
    }
}   

Time Complexity: Such an arrangement of binary search makes it execute in O(log N) time, assuming N as the size of the string. In order to pick any of the midpoints, the sliding window mechanism has to look for the substrings in O(N) time. Therefore, the total time complexity comes out to be O(N log N).

Space Complexity: Space complexity is O(1) because the number of extra variables used in this algorithm are a few counts and indices only.

Conclusion

This approach gives an efficient solution to the problem of identifying the longest string of strings that are made up of vowels only. Thus, by applying binary search along with the sliding window approach, we are able to consider a much more sophisticated yet more efficient elaboration of a solution compared to other, perhaps more naive, yet time-consuming ones.

The Java implementation provided is efficient enough, and the code given for this problem is easy to understand, so it can be used for competitive programming as well as for practical purposes.

Next TopicFind-the-longest-substring-having-k-distinct-vowels-in-java

← prev next →