Count subarrays having a single distinct element that can be obtained from a given array
Given an array arr[] of size N, the task is to count the number of subarrays consisting of a single distinct element that can be obtained from a given array.
Examples:
Input: N = 4, arr[] = { 2, 2, 2, 2 }
Output: 7
Explanation: All such subarrays {{2}, {2}, {2}, {2}, {2, 2}, {2, 2, 2}, {2, 2, 2, 2}}. Therefore, total count of such subarrays are 7.Input: N = 3, arr[] = { 1, 1, 3 }
Output: 4
Approach: Follow the steps below to solve the problem:
- Initialize a Map to store the frequency of array elements.
- Traverse the array and update frequency of each element in the Map.
- Traverse the Map and check if frequency of current element is greater than 1.
- If found to be true, then increment count of subarrays by frequency of current element – 1.
Below is the implementation of the above approach:
C++
// C++ program for the above approach #include <bits/stdc++.h> using namespace std; // Function to count subarrays of // single distinct element into // which given array can be split void divisionalArrays( int arr[3], int N) { // Stores the count int sum = N; // Stores frequency of // array elements unordered_map< int , int > mp; // Traverse the array for ( int i = 0; i < N; i++) { mp[arr[i]]++; } // Traverse the map for ( auto x : mp) { if (x.second > 1) { // Increase count of // subarrays by (frequency-1) sum += x.second - 1; } } cout << sum << endl; } // Driver Code int main() { int arr[] = { 1, 1, 3 }; int N = sizeof (arr) / sizeof (arr[0]); divisionalArrays(arr, N); } |
Java
// Java program for the above approach import java.io.*; import java.util.*; class GFG { // Function to count subarrays of // single distinct element into // which given array can be split static void divisionalArrays( int arr[], int N) { // Stores the count int sum = N; // Stores frequency of // array elements HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>(); // Traverse the array for ( int i = 0 ; i < N; i++) { if (mp.containsKey(arr[i])) { mp.put(arr[i], mp.get(arr[i]) + 1 ); } else { mp.put(arr[i], 1 ); } } // Traverse the map for (Map.Entry x : mp.entrySet()) { if (( int )x.getValue() > 1 ) { // Increase count of // subarrays by (frequency-1) sum += ( int )x.getValue() - 1 ; } } System.out.println(sum); } // Driver Code public static void main(String[] args) { int arr[] = { 1 , 1 , 3 }; int N = arr.length; divisionalArrays(arr, N); } } // This code is contributed by Dharanendra L V |
Python3
# python 3 program for the above approach from collections import defaultdict # Function to count subarrays of # single distinct element into # which given array can be split def divisionalArrays(arr, N): # Stores the count sum = N # Stores frequency of # array elements mp = defaultdict( int ) # Traverse the array for i in range (N): mp[arr[i]] + = 1 # Traverse the map for x in mp: if (mp[x] > 1 ): # Increase count of # subarrays by (frequency-1) sum + = mp[x] - 1 print ( sum ) # Driver Code if __name__ = = "__main__" : arr = [ 1 , 1 , 3 ] N = len (arr) divisionalArrays(arr, N) # This code is contributed by ukasp. |
C#
// C# program for the above approach using System; using System.Collections.Generic; class GFG{ // Function to count subarrays of // single distinct element into // which given array can be split static void divisionalArrays( int []arr, int N) { // Stores the count int sum = N; // Stores frequency of // array elements Dictionary< int , int > mp = new Dictionary< int , int >(); // Traverse the array for ( int i = 0; i < N; i++) { if (mp.ContainsKey(arr[i])) { mp[arr[i]] = mp[arr[i]] + 1; } else { mp.Add(arr[i], 1); } } // Traverse the map foreach (KeyValuePair< int , int > x in mp) { if (( int )x.Value > 1) { // Increase count of // subarrays by (frequency-1) sum += ( int )x.Value - 1; } } Console.WriteLine(sum); } // Driver Code public static void Main(String[] args) { int []arr = { 1, 1, 3 }; int N = arr.Length; divisionalArrays(arr, N); } } // This code is contributed by shikhasingrajput |
Javascript
<script> // JavaScript program for the above approach // Function to count subarrays of // single distinct element into // which given array can be split function divisionalArrays(arr, N) { // Stores the count var sum = N; // Stores frequency of // array elements var mp = new Map(); // Traverse the array for ( var i = 0; i < N; i++) { if (mp.has(arr[i])) { mp.set(arr[i], mp.get(arr[i])+1); } else { mp.set(arr[i],1); } } // Traverse the map mp.forEach((value, key) => { if (value > 1) { // Increase count of // subarrays by (frequency-1) sum += value - 1; } }); document.write( sum); } // Driver Code var arr =[1, 1, 3]; var N = arr.length; divisionalArrays(arr, N); </script> |
Output:
4
Time Complexity: O(N)
Auxiliary Space: O(N)
Please Login to comment...