# Count subarrays having total distinct elements same as original array in C++

We are given an array arr[] containing integers. The goal is to count all subarrays of arr[] such that the number of distinct elements in each is the same as the number of distinct elements in the original array. If the original array is [1,1,2,3] then subarrays will be [1,2,3] and [1,1,2,3].

Total distinct elements in the original array is 3. Total distinct elements in both subarrays is also 3

Let us understand with examples.

Input − arr[] = {1,2,1,2,3,4,2 };

Output − Count of subarrays having total distinct elements same as an original array is − 6

Explanation − Distinct elements in arr[] are 4 (1,2,3,4). Subarrays with the same number of distinct elements are: ( count distinct from left to right )

[1,2,1,2,3,4], [2,1,2,3,4], [1,2,3,4], [1,2,3,4,2], [2,1,2,3,4,2], [1,2,1,2,3,4,2 ]

Input − arr[] = {8,7,5,6,10 };

Output − Count of subarrays having total distinct elements same as an original array is − 1

Explanation − Distinct elements in arr[] are 5 (5,6,7,8,10). Subarrays with same number of distinct elements are: ( count distinct from left to right ) [8,7,6,5,10]. 1 only

## The approach used in the below program is as follows

• Take an array arr[] of integer numbers and calculate the size of an array.

• Function sub_ele_diff_one(int arr[], int size) takes the array and returns a count of subarrays with consecutive elements differing by 1.

• Take a temporary variable count and variables right and left.

• Take a variable of type unordered_map for creating the random pairs.

• Start loop FOR from 0 till the size of an array and inside it set the value of arr[i] inside the unordered_map.

• Now, calculate the size of an unordered_map and clear the unordered_map.

• Start loop FOR from 0 till the size of an array.

• Inside the loop, start WHILE till right < size and left < size of an unordered_map

• Pre-Increment the value of um[arr[right]]

• Now, check if um[arr[right]] = 1 then pre increment the value of left by 1.

• Outside the WHILE, pre-increment the value of right by 1.

• Check IF left = size of an unordered_map then set count to count + size - right + 1

• Decrement the um[arr[i]] by 1

• Check IF um[arr[i]] = 0 then decrement the left by 1

• Return the count

• Print the result.

## Example

Live Demo

#include <bits/stdc++.h>
using namespace std;
int sub_distinct(int arr[], int size){
int count = 0, right = 0, left = 0;
unordered_map<int, int> um;
for (int i = 0; i < size; ++i){
um[arr[i]] = 1;
}
int um_size = um.size();
um.clear();
for(int i = 0; i < size; ++i){
while (right < size && left < um_size){
++um[arr[right]];
if (um[arr[right]] == 1){
++left;
}
++right;
}
if (left == um_size){
count = count + (size - right + 1);
}
--um[arr[i]];
if (um[arr[i]] == 0){
--left;
}
}
return count;
}
int main(){
int arr[] = {4, 3, 2, 5};
int size = sizeof(arr) / sizeof(arr[0]);
cout<<"Count of subarrays having total distinct elements same as original array are: "<<sub_distinct(arr, size);
return 0;
}

## Output

If we run the above code it will generate the following output −

Count of subarrays having total distinct elements same as original array are: 1