具有至少 K 个具有相同频率的成对不同字符的子串计数

给定一个字符串S和一个整数K ，任务是找到由至少K 个具有相同频率的成对不同字符组成的子字符串的数量。

例子：

Input: S = “abasa”, K = 2 
Output: 5 
Explanation: 
The substrings in having 2 pairwise distinct characters with same frequency are {“ab”, “ba”, “as”, “sa”, “bas”}.
Input: S = “abhay”, K = 3 
Output: 4 
Explanation: 
The substrings having 3 pairwise distinct characters with same frequency are {“abh”, “bha”, “hay”, “bhay”}.

朴素的方法：解决这个问题的最简单的方法是生成给定字符串的所有可能的子字符串，并检查两个条件是否都满足。如果发现是真的，增加计数。最后，打印count 。

时间复杂度： O(N ³ )
辅助空间： O(1)

高效方法：对上述方法进行优化，请按照以下步骤解决问题：

• 检查每个字符的频率是否相同。如果发现为真，只需生成所有子串以检查每个字符满足至少N对不同字符。
• 预先计算字符的频率以检查每个子字符串的条件。

下面是上述方法的实现：

C++

// C++ Program for the above approach
#include 
using namespace std;
 
// Function to find the substring with K
// pairwise distinct characters and
// with same frequency
int no_of_substring(string s, int N)
{
    // Stores the occurrence of each
    // character in the substring
    int fre[26];
 
    int str_len;
 
    // Length of the string
    str_len = (int)s.length();
 
    int count = 0;
 
    // Iterate over the string
    for (int i = 0; i < str_len; i++) {
 
        // Set all values at each index to zero
        memset(fre, 0, sizeof(fre));
        int max_index = 0;
 
        // Stores the count of
        // unique characters
        int dist = 0;
 
        // Moving the substring ending at j
        for (int j = i; j < str_len; j++) {
 
            // Calculate the index of
            // character in frequency array
            int x = s[j] - 'a';
 
            if (fre[x] == 0)
                dist++;
 
            // Increment the frequency
            fre[x]++;
 
            // Update the maximum index
            max_index = max(max_index, fre[x]);
 
            // Check for both the conditions
            if (dist >= N && ((max_index * dist)
                              == (j - i + 1)))
                count++;
        }
    }
 
    // Return the answer
    return count;
}
 
// Driver Code
int main()
{
    string s = "abhay";
    int N = 3;
 
    // Function call
    cout << no_of_substring(s, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the subString with K
// pairwise distinct characters and
// with same frequency
static int no_of_subString(String s, int N)
{
     
    // Stores the occurrence of each
    // character in the subString
    int fre[] = new int[26];
 
    int str_len;
 
    // Length of the String
    str_len = (int)s.length();
 
    int count = 0;
 
    // Iterate over the String
    for(int i = 0; i < str_len; i++)
    {
         
        // Set all values at each index to zero
        Arrays.fill(fre, 0);
         
        int max_index = 0;
 
        // Stores the count of
        // unique characters
        int dist = 0;
 
        // Moving the subString ending at j
        for(int j = i; j < str_len; j++)
        {
             
            // Calculate the index of
            // character in frequency array
            int x = s.charAt(j) - 'a';
 
            if (fre[x] == 0)
                dist++;
 
            // Increment the frequency
            fre[x]++;
 
            // Update the maximum index
            max_index = Math.max(max_index, fre[x]);
 
            // Check for both the conditions
            if (dist >= N && ((max_index * dist) ==
                              (j - i + 1)))
                count++;
        }
    }
 
    // Return the answer
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
    String s = "abhay";
    int N = 3;
 
    // Function call
    System.out.print(no_of_subString(s, N));
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program to implement
# the above approach
 
# Function to find the substring with K
# pairwise distinct characters and
# with same frequency
def no_of_substring(s, N):
 
    # Length of the string
    str_len = len(s)
 
    count = 0
 
    # Iterate over the string
    for i in range(str_len):
 
        # Stores the occurrence of each
        # character in the substring
        # Set all values at each index to zero
        fre = [0] * 26
 
        max_index = 0
 
        # Stores the count of
        # unique characters
        dist = 0
 
        # Moving the substring ending at j
        for j in range(i, str_len):
 
            # Calculate the index of
            # character in frequency array
            x = ord(s[j]) - ord('a')
 
            if (fre[x] == 0):
                dist += 1
 
            # Increment the frequency
            fre[x] += 1
 
            # Update the maximum index
            max_index = max(max_index, fre[x])
 
            # Check for both the conditions
            if(dist >= N and
             ((max_index * dist) == (j - i + 1))):
                count += 1
 
    # Return the answer
    return count
 
# Driver Code
s = "abhay"
N = 3
 
# Function call
print(no_of_substring(s, N))
 
# This code is contributed by Shivam Singh

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the subString with K
// pairwise distinct characters and
// with same frequency
static int no_of_subString(String s, int N)
{
     
    // Stores the occurrence of each
    // character in the subString
    int []fre = new int[26];
 
    int str_len;
 
    // Length of the String
    str_len = (int)s.Length;
 
    int count = 0;
 
    // Iterate over the String
    for(int i = 0; i < str_len; i++)
    {
         
        // Set all values at each index to zero
        fre = new int[26];
         
        int max_index = 0;
 
        // Stores the count of
        // unique characters
        int dist = 0;
 
        // Moving the subString ending at j
        for(int j = i; j < str_len; j++)
        {
             
            // Calculate the index of
            // character in frequency array
            int x = s[j] - 'a';
 
            if (fre[x] == 0)
                dist++;
 
            // Increment the frequency
            fre[x]++;
 
            // Update the maximum index
            max_index = Math.Max(max_index, fre[x]);
 
            // Check for both the conditions
            if (dist >= N && ((max_index * dist) ==
                              (j - i + 1)))
                count++;
        }
    }
 
    // Return the answer
    return count;
}
 
// Driver Code
public static void Main(String[] args)
{
    String s = "abhay";
    int N = 3;
 
    // Function call
    Console.Write(no_of_subString(s, N));
}
}
 
// This code is contributed by Amit Katiyar

Javascript

 
// javascript program for the above approach
 
// Function to find the subString with K
// pairwise distinct characters and
// with same frequency
function no_of_subString(s , N)
{
     
    // Stores the occurrence of each
    // character in the subString
    var fre = Array.from({length: 26}, (_, i) => 0);
 
    var str_len;
 
    // Length of the String
    str_len = parseInt(s.length);
 
    var count = 0;
 
    // Iterate over the String
    for(i = 0; i < str_len; i++)
    {
         
        // Set all values at each index to zero
        fre = Array(26).fill(0);
         
        var max_index = 0;
 
        // Stores the count of
        // unique characters
        var dist = 0;
 
        // Moving the subString ending at j
        for(j = i; j < str_len; j++)
        {
             
            // Calculate the index of
            // character in frequency array
            var x = s.charAt(j).charCodeAt(0) - 'a'.charCodeAt(0);
 
            if (fre[x] == 0)
                dist++;
 
            // Increment the frequency
            fre[x]++;
 
            // Update the maximum index
            max_index = Math.max(max_index, fre[x]);
 
            // Check for both the conditions
            if (dist >= N && ((max_index * dist) ==
                              (j - i + 1)))
                count++;
        }
    }
 
    // Return the answer
    return count;
}
 
// Driver Code
var s = "abhay";
var N = 3;
 
// Function call
document.write(no_of_subString(s, N));
 
// This code contributed by shikhasingrajput

输出：

4

时间复杂度： O(N ² )
辅助空间： O(1)