Count subarrays having at least X distinct elements that occur exactly Y times

Given three integers N, X, Y, and an array arr[] of size N, the task is to find the count of subarrays having at least X distinct elements that occur only Y times.

Example:

Input: N = 9, X = 2, Y = 2, arr[] = {2, 1, 2, 5, 3, 1, 3, 2, 5}
Output:10
Explanation:
Subarrays with at least X distinct elements occurring exactly Y times are: 
{2, 1, 2, 5, 3, 1}, {2, 1, 2, 5, 3, 1, 3}, {2, 1, 2, 5, 3, 1, 3, 2}, {2, 1, 2, 5, 3, 1, 3, 2, 5},  
{1, 2, 5, 3, 1, 3}, {1, 2, 5, 3, 1, 3, 2}, {1, 2, 5, 3, 1, 3, 2, 5}, {2, 5, 3, 1, 3, 2},  
{2, 5, 3, 1, 3, 2, 5}, {5, 3, 1, 3, 2, 5}

Input: N = 3, X = 1, Y = 2, arr[] = {1, 3, 5}
Output: 0
Explanation: No element is occurring twice in the given array

Naive Approach: The idea is to generate all possible subarrays of the given array and traverse over the generated subarrays to find the frequency of all distinct elements. Then check whether there are at least X distinct elements that occur only Y times in the subarray. If found, increment the result and return the final result.

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

Efficient Approach: The problem can also be solved in an efficient way based on the following idea:

Keep track of the frequency of elements while generating the subarray and count of unique elements with exactly Y occurrences in that subarray with the help of hashing. In this way, there is no need to build all the subarrays and check them afterward.

Follow the steps below to implement the above idea:

• Iterate from i = 0 to N - 1:
  • Declare a hash map (say cntFreq) to store the frequency of the distinct elements in the subarray.
  • Initialize a variable (say cntDistinct) to store the number of distinct elements that occur exactly Y times in the subarray.
  • Iterate using a nested loop from j = i to N to consider all the subarrays:
    • Increment the frequency of arr[j].
    • If the frequency is Y then increment cntDistinct.
    • If frequency exceeds Y and becomes Y+1, decrement cntDistinct,
  • If the subarray has at least X distinct elements satisfying the condition then increase the count of subarrays fulfilling the condition.
• Finally, return the count of the subarrays.

Below is the implementation of the above approach:

// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to count the number of subarrays
int countSubarray(int arr[], int X, int Y, int N)
{
    // To store the total number of subarrays
    // that satisfy the condition.
    int cntSub = 0;

    for (int i = 0; i < N; i++) {
        int cntDistinct = 0;

        // To store frequency of distinct elements
        unordered_map<int, int> cntFreq;
        for (int j = i; j < N; j++) {

            // Increment the frequency of
            // current element in map
            cntFreq[arr[j]]++;
            if (cntFreq[arr[j]] == Y) {
                cntDistinct++;
            }
            else if (cntFreq[arr[j]] == Y + 1) {

                // Decrement if current element's
                // frequency equal Y+1 because the
                // cntDistinct is incremented at Y.
                cntDistinct--;
            }

            // Increment cntSub if
            // cntDistinct >= X
            if (cntDistinct >= X) {
                cntSub++;
            }
        }
    }

    // Print count of subarrays
    return cntSub;
}

// Driver Code
int main()
{
    int N = 9, X = 2, Y = 2;
    int arr[] = { 2, 1, 2, 5, 3, 1, 3, 2, 5 };

    // Function call
    cout << countSubarray(arr, X, Y, N);
    return 0;
}

// Java code to implement the approach
import java.util.TreeMap;

class GFG {

  // Function to count the number of subarrays
  static int countSubarray(int arr[], int X, int Y, int N) 
  {
    
    // To store the total number of subarrays
    // that satisfy the condition.
    int cntSub = 0;

    for (int i = 0; i < N; i++) {
      int cntDistinct = 0;

      // To store frequency of distinct elements
      TreeMap<Integer, Integer> cntFreq = new TreeMap<Integer, Integer>();
      for (int j = i; j < N; j++) {

        // Increment the frequency of
        // current element in map
        if (cntFreq.containsKey(arr[j])) {
          cntFreq.put(arr[j], cntFreq.get(arr[j]) + 1);
        } else {
          cntFreq.put(arr[j], 1);
        }
        if (cntFreq.get(arr[j]) == Y) {
          cntDistinct++;
        } else if (cntFreq.get(arr[j]) == Y + 1) {

          // Decrement if current element's
          // frequency equal Y+1 because the
          // cntDistinct is incremented at Y.
          cntDistinct--;
        }

        // Increment cntSub if
        // cntDistinct >= X
        if (cntDistinct >= X) {
          cntSub++;
        }
      }
    }

    // Print count of subarrays
    return cntSub;
  }

  // Driver Code
  public static void main(String args[]) {
    int N = 9, X = 2, Y = 2;
    int arr[] = { 2, 1, 2, 5, 3, 1, 3, 2, 5 };

    // Function call
    System.out.println(countSubarray(arr, X, Y, N));
  }
}

// This code is contributed by gfgking.

# Python3 code to implement the approach

# Function to count the number of subarrays
def countSubarray(arr,  X,  Y,  N) :

    # To store the total number of subarrays
    # that satisfy the condition.
    cntSub = 0;

    for i in range(N) :
        cntDistinct = 0;

        # To store frequency of distinct elements
        cntFreq = dict.fromkeys(arr,0);
        for j in range(i, N) :

            # Increment the frequency of
            # current element in map
            cntFreq[arr[j]] += 1;
            
            if (cntFreq[arr[j]] == Y) :
                cntDistinct += 1;
            
            elif (cntFreq[arr[j]] == Y + 1) :

                # Decrement if current element's
                # frequency equal Y+1 because the
                # cntDistinct is incremented at Y.
                cntDistinct -= 1;

            # Increment cntSub if
            # cntDistinct >= X
            if (cntDistinct >= X) :
                cntSub += 1;

    # Print count of subarrays
    return cntSub;

# Driver Code
if __name__ == "__main__" :

    N = 9; X = 2; Y = 2;
    arr = [ 2, 1, 2, 5, 3, 1, 3, 2, 5 ];

    # Function call
    print(countSubarray(arr, X, Y, N));
    
    # This code is contributed by AnkThon

// C# code to implement the approach
using System;
using System.Collections.Generic;

public class GFG {

  // Function to count the number of subarrays
  static int countSubarray(int []arr, int X, int Y, int N) 
  {
    
    // To store the total number of subarrays
    // that satisfy the condition.
    int cntSub = 0;

    for (int i = 0; i < N; i++) {
      int cntDistinct = 0;

      // To store frequency of distinct elements
      Dictionary<int, int> cntFreq = new Dictionary<int, int>();
      
      for (int j = i; j < N; j++) {

        // Increment the frequency of
        // current element in map
        if (cntFreq.ContainsKey(arr[j])) {
          cntFreq[arr[j]] =  cntFreq[arr[j]] + 1;
        } else {
          cntFreq.Add(arr[j], 1);
        }
        if (cntFreq[arr[j]] == Y) {
          cntDistinct++;
        } else if (cntFreq[arr[j]] == Y + 1) {

          // Decrement if current element's
          // frequency equal Y+1 because the
          // cntDistinct is incremented at Y.
          cntDistinct--;
        }

        // Increment cntSub if
        // cntDistinct >= X
        if (cntDistinct >= X) {
          cntSub++;
        }
      }
    }

    // Print count of subarrays
    return cntSub;
  }

  // Driver Code
  public static void Main(string []args) {
    int N = 9, X = 2, Y = 2;
    int []arr = { 2, 1, 2, 5, 3, 1, 3, 2, 5 };

    // Function call
    Console.WriteLine(countSubarray(arr, X, Y, N));
  }
}

// This code is contributed by AnkThon

<script>
    // Javascript program to Count subarrays having 
    // at least X distinct elements that occur exactly Y times
    
    // Function to count the number of subarrays
    function countSubarray(arr, X, Y, N){
        // To store the total number of subarrays
        // that satisfy the condition.
        var cntSub = 0;
     
        for (var i = 0; i < N; i++) {
          var cntDistinct = 0;
     
          // To store frequency of distinct elements
          const cntFreq = new Map();
          for (var j = i; j < N; j++) {
     
            // Increment the frequency of
            // current element in map
            if (cntFreq.has(arr[j])) {
              cntFreq.set(arr[j], cntFreq.get(arr[j]) + 1);
            } else {
              cntFreq.set(arr[j], 1);
            }
            if (cntFreq.get(arr[j]) == Y) {
              cntDistinct++;
            } else if (cntFreq.get(arr[j]) == Y + 1) {
     
              // Decrement if current element's
              // frequency equal Y+1 because the
              // cntDistinct is incremented at Y.
              cntDistinct--;
            }
     
            // Increment cntSub if
            // cntDistinct >= X
            if (cntDistinct >= X) {
              cntSub++;
            }
          }
        }
     
        // Print count of subarrays
        return cntSub;
    }
    
    // Driver Code
    var N = 9, X = 2, Y = 2;
    var arr = [2, 1, 2, 5, 3, 1, 3, 2, 5];
    
    // Function call
    document.write(countSubarray(arr, X, Y, N));
    
    //This code is contributed by shruti456rawal
</script>

10

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