具有K个不同元音的最长子串

给定字符串s，我们必须找到s的最长子字符串的长度，该子字符串恰好包含K个不同的元音。
注意：将大写和小写字符视为两个不同的字符。
例子：

Input : s = “tHeracEBetwEEntheTwo”, k = 1 
Output : 14 
Explanation : Longest substring with only 1 vowel is “cEBetwEEntheTw” 
and its length is 14.
Input : s = “artyebui”, k = 2 
Output : 6 
Explanation : Longest substring with only 2 vowel is “rtyebu”

蛮力法：对于每个子串，我们检查K个不同元音的条件，并检查其长度。最后，最大长度将是结果。
高效的方法：在这里，我们保持子串中出现的元音计数。直到K不为零，我们才算出子串中出现的不同元音。当K变为负数时，我们开始删除直到那个时候为止发现的子串的第一个元音，以便之后可能再有新的子串(更大的length)成为可能。删除元音时，我们会减少其数量，以便新的子字符串可以包含出现在字符串后半部分的元音。当K为0时，我们得到子串的长度。
下面是上述方法的实现

C++

// CPP program to find the longest substring
// with k distinct vowels.
#include 
using namespace std;
 
#define MAX 128
 
// Function to check whether a character is
// vowel or not
bool isVowel(char x)
{
    return (x == 'a' || x == 'e' || x == 'i' ||
            x == 'o' || x == 'u' || x == 'A' ||
            x == 'E' || x == 'I' || x == 'O' ||
            x == 'U');
}
 
int KDistinctVowel(char s[], int k)
{
    // length of string
    int n = strlen(s);
 
    // array for count of characters
    int c[MAX];
    memset(c, 0, sizeof(c));
 
    // Initialize result to be
    // negative
    int result = -1;
 
    for (int i = 0, j = -1; i < n; ++i) {
 
        int x = s[i];
 
        // If letter is vowel then we
        // increment its count value
        // and decrease the k value so
        // that if we again encounter the
        // same vowel character then we
        // don't consider it for our result
        if (isVowel(x)) {
            if (++c[x] == 1) {
 
                // Decrementing the K value
                --k;
            }
        }
 
        // Till k is 0 above if condition run
        // after that this while loop condition
        // also become active. Here what we have
        // done actually is that, if K is less
        // than 0 then we eliminate the first
        // vowel we have encountered till that
        // time . Now K is incremented and k
        // becomes 0. So, now we calculate the
        // length of substring from the present
        // index to the deleted index of vowel
        // which result in our results.
        while (k < 0) {
 
            x = s[++j];
            if (isVowel(x)) {
 
                // decresing the count
                // so that it may appear
                // in another substring
                // appearing after this
                // present substring
                if (--c[x] == 0) {
 
                    // incrementing the K value
                    ++k;
                }
            }
        }
 
        // Checking the maximum value
        // of the result by comparing
        // the length of substring
        // whenever K value is 0 means
        // K distinct vowel is present
        // in substring
        if (k == 0)
            result = max(result, i - j);       
    }
    return result;
}
 
// Driver code
int main(void)
{
    char s[] = "tHeracEBetwEEntheTwo";
    int k = 1;
    cout << KDistinctVowel(s, k);
    return 0;
}

Java

// Java program to find the longest substring
// with k distinct vowels.
 
class GFG {
 
    static int MAX = 128;
 
    // Function to check whether a character is
    // vowel or not
    static boolean isVowel(char x) {
        return (x == 'a' || x == 'e' || x == 'i' ||
                x == 'o' || x == 'u' || x == 'A' ||
                x == 'E' || x == 'I' || x == 'O' ||
                x == 'U');
    }
 
    static int KDistinctVowel(String s, int k) {
        // length of string
        int n = s.length();
 
        // array for count of characters
        int[] c = new int[MAX];
        //Array.Clear(c, 0, c.Length);
 
        // Initialize result to be
        // negative
        int result = -1;
 
        for (int i = 0, j = -1; i < n; ++i) {
 
            char x = s.charAt(i);
 
            // If letter is vowel then we
            // increment its count value
            // and decrease the k value so
            // that if we again encounter the
            // same vowel character then we
            // don't consider it for our result
            if (isVowel(x)) {
                if (++c[x] == 1) {
 
                    // Decrementing the K value
                    --k;
                }
            }
 
            // Till k is 0 above if condition run
            // after that this while loop condition
            // also become active. Here what we have
            // done actually is that, if K is less
            // than 0 then we eliminate the first
            // vowel we have encountered till that
            // time . Now K is incremented and k
            // becomes 0. So, now we calculate the
            // length of substring from the present
            // index to the deleted index of vowel
            // which result in our results.
            while (k < 0) {
 
                x = s.charAt(++j);
                if (isVowel(x)) {
 
                    // decresing the count
                    // so that it may appear
                    // in another substring
                    // appearing after this
                    // present substring
                    if (--c[x] == 0) {
 
                        // incrementing the K value
                        ++k;
                    }
                }
            }
 
            // Checking the maximum value
            // of the result by comparing
            // the length of substring
            // whenever K value is 0 means
            // K distinct vowel is present
            // in substring
            if (k == 0) {
                result = Math.max(result, i - j);
            }
        }
        return result;
    }
 
    // Driver code
    public static void main(String[] args) {
        String s = "tHeracEBetwEEntheTwo";
        int k = 1;
        System.out.println(KDistinctVowel(s, k));
    }
}
 
/* This Java code is contributed by Rajput-Ji*/

Python3

# Python3 program to find the longest substring
# with k distinct vowels.
 
MAX = 128
 
# Function to check whether a character is
# vowel or not
def isVowel(x):
 
    return (x == 'a' or x == 'e' or x == 'i' or
            x == 'o' or x == 'u' or x == 'A' or
            x == 'E' or x == 'I' or x == 'O' or
            x == 'U')
 
def KDistinctVowel(c,k):
    n = len(s)
 
    c = [0 for i in range(MAX)]
    result = -1
 
    j = -1
 
    for i in range(n):
        x=s[i]
 
        # If letter is vowel then we
        # increment its count value
        # and decrease the k value so
        # that if we again encounter the
        # same vowel character then we
        # don't consider it for our result
 
        if isVowel(x):
            c[ord(x)] += 1
            if c[ord(x)] == 1:
                k -= 1
 
        # Till k is 0 above if condition run
        # after that this while loop condition
        # also become active. Here what we have
        # done actually is that, if K is less
        # than 0 then we eliminate the first
        # vowel we have encountered till that
        # time . Now K is incremented and k
        # becomes 0. So, now we calculate the
        # length of substring from the present
        # index to the deleted index of vowel
        # which result in our results.
        while k < 0:
            j += 1
            x = s[j]
            if isVowel(x):
                 
                # decresing the count
                # so that it may appear
                # in another substring
                # appearing after this
                # present substring
                c[ord(x)] -= 1
                k += 1
                 
        # Checking the maximum value
        # of the result by comparing
        # the length of substring
        # whenever K value is 0 means
        # K distinct vowel is present
        # in substring    
 
        if k == 0:
            result = max(result, i - j)
 
    return result
 
s = "tHeracEBetwEEntheTwo"
k = 1
print(KDistinctVowel(s, k))
 
# This code is contributed by mohit kumar 29

C#

// C# program to find the longest substring
// with k distinct vowels.
using System;
 
class GFG {
     
    static int MAX = 128;
     
    // Function to check whether a character is
    // vowel or not
    static bool isVowel(char x)
    {
        return (x == 'a' || x == 'e' || x == 'i' ||
                x == 'o' || x == 'u' || x == 'A' ||
                x == 'E' || x == 'I' || x == 'O' ||
                x == 'U');
    }
     
    static int KDistinctVowel(string s, int k)
    {
        // length of string
        int n = s.Length;
     
        // array for count of characters
        int []c = new int[MAX];
        Array.Clear(c, 0, c.Length);
     
        // Initialize result to be
        // negative
        int result = -1;
     
        for (int i = 0, j = -1; i < n; ++i) {
     
            char x = s[i];
     
            // If letter is vowel then we
            // increment its count value
            // and decrease the k value so
            // that if we again encounter the
            // same vowel character then we
            // don't consider it for our result
            if (isVowel(x)) {
                if (++c[x] == 1) {
     
                    // Decrementing the K value
                    --k;
                }
            }
     
            // Till k is 0 above if condition run
            // after that this while loop condition
            // also become active. Here what we have
            // done actually is that, if K is less
            // than 0 then we eliminate the first
            // vowel we have encountered till that
            // time . Now K is incremented and k
            // becomes 0. So, now we calculate the
            // length of substring from the present
            // index to the deleted index of vowel
            // which result in our results.
            while (k < 0) {
     
                x = s[++j];
                if (isVowel(x)) {
     
                    // decresing the count
                    // so that it may appear
                    // in another substring
                    // appearing after this
                    // present substring
                    if (--c[x] == 0) {
     
                        // incrementing the K value
                        ++k;
                    }
                }
            }
     
            // Checking the maximum value
            // of the result by comparing
            // the length of substring
            // whenever K value is 0 means
            // K distinct vowel is present
            // in substring
            if (k == 0) {
                result = Math.Max(result, i - j);
            }
        }
        return result;
    }
     
    // Driver code
    static void Main()
    {
        string s = "tHeracEBetwEEntheTwo";
        int k = 1;
        Console.Write(KDistinctVowel(s, k));
    }
}
 
// This code is contributed Manish Shaw
// (manishshaw1)

Javascript

// Javascript program to find the longest substring
// with k distinct vowels.
     
    let MAX = 128;
     
    // Function to check whether a character is
    // vowel or not
    function isVowel(x)
    {
        return (x == 'a' || x == 'e' || x == 'i' ||
                x == 'o' || x == 'u' || x == 'A' ||
                x == 'E' || x == 'I' || x == 'O' ||
                x == 'U');
    }
     
    function KDistinctVowel(s,k)
    {
        // length of string
        let n = s.length;
   
        // array for count of characters
        let c = new Array(MAX);
        for(let i=0;i<c.length;i++)
        {
            c[i]=0;
        }
        //Array.Clear(c, 0, c.Length);
   
        // Initialize result to be
        // negative
        let result = -1;
   
        for (let i = 0, j = -1; i < n; ++i) {
   
            let x = s[i];
   
            // If letter is vowel then we
            // increment its count value
            // and decrease the k value so
            // that if we again encounter the
            // same vowel character then we
            // don't consider it for our result
            if (isVowel(x)) {
                if (++c[x.charCodeAt(0)] == 1) {
   
                    // Decrementing the K value
                    --k;
                }
            }
   
            // Till k is 0 above if condition run
            // after that this while loop condition
            // also become active. Here what we have
            // done actually is that, if K is less
            // than 0 then we eliminate the first
            // vowel we have encountered till that
            // time . Now K is incremented and k
            // becomes 0. So, now we calculate the
            // length of substring from the present
            // index to the deleted index of vowel
            // which result in our results.
            while (k < 0) {
   
                x = s[++j];
                if (isVowel(x)) {
   
                    // decresing the count
                    // so that it may appear
                    // in another substring
                    // appearing after this
                    // present substring
                    if (--c[x.charCodeAt(0)] == 0) {
   
                        // incrementing the K value
                        ++k;
                    }
                }
            }
   
            // Checking the maximum value
            // of the result by comparing
            // the length of substring
            // whenever K value is 0 means
            // K distinct vowel is present
            // in substring
            if (k == 0) {
                result = Math.max(result, i - j);
            }
        }
        return result;
    }
     
    // Driver code
    let s = "tHeracEBetwEEntheTwo";
    let k = 1;
    document.write(KDistinctVowel(s, k));
        
    // This code is contributed by rag2127

输出：

7

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。