Skip to content
Related Articles

Related Articles

Count pairs of equal array elements remaining after every removal
  • Last Updated : 07 Jan, 2021

Given an array arr[] of size N, the task for every array element arr[i], is to count the number of pairs of equal elements that can be obtained by removing arr[i] from the array.

Examples:

Input: arr[] = { 1, 1, 1, 2 } 
Output: 1 1 1 3 
Explanation: 
Removing arr[0] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[1] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[2] from the array modifies arr[] to { 1, 1, 2 } and count of pairs of equal elements = 1 
Removing arr[3] from the array modifies arr[] to { 1, 1, 1 } and count of pairs of equal elements = 3 
Therefore, the required output is 1 1 1 3.

Input: arr[] = { 2, 3, 4, 3, 2 } 
Output: 1 1 2 1 1

Naive Approach: The simplest approach to solve this problem is to traverse the array and for every ith element remove arr[i] from the array and print the count of pairs of equal array elements remaining in the array. 



Time Complexity: O(N2)
Auxiliary space: O(N)

Efficient Approach: Follow the steps below to solve the problem:

  • Initialize a map, say mp, to store the frequency of each distinct element of the array.
  • Initialize a variable, say cntPairs, to store the total count of pairs of equal array elements.
  • Traverse the map and store the total count of pairs of equal elements by incrementing the value of cntPairs by (mp[i] * (mp[i] – 1)) / 2.
  • Finally, traverse the array. For every ith element, print the value of (cntPairs – mp[i] + 1), which denotes the count of pairs of equal array elements by removing arr[i] from the array.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count pairs of equal elements
// by removing arr[i] from the array
void pairs_after_removing(int arr[], int N)
{
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
 
    // Store frequency of each
    // distinct array element
    unordered_map<int, int> mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Update frequency of arr[i]
        mp[arr[i]]++;
    }
 
    // Traverse the map
    for (auto element : mp) {
 
        // Stores key of an element
        int i = element.first;
        cntPairs += mp[i] * (mp[i] - 1) / 2;
    }
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed
            = cntPairs + 1 - mp[arr[i]];
 
        cout << pairs_after_arr_i_removed << ' ';
    }
    return;
}
 
// Driver Code
int main()
{
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    pairs_after_removing(arr, N);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.util.*;
  
class GFG{
  
// Function to count pairs of equal elements
// by removing arr[i] from the array
static void pairs_after_removing(int arr[], int N)
{
     
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
  
    // Store frequency of each
    // distinct array element
    Map<Integer,
        Integer> mp = new HashMap<Integer,
                                  Integer>();
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Update frequency of arr[i]
        mp.put(arr[i], mp.getOrDefault(arr[i], 0) + 1);
    }
  
    // Traverse the map
    for(Map.Entry<Integer,
                  Integer> element : mp.entrySet())
    {
         
        // Stores key of an element
        int i = element.getKey();
        cntPairs += mp.get(i) * (mp.get(i) - 1) / 2;
    }
  
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed = cntPairs +
                           1 - mp.get(arr[i]);
  
        System.out.print(pairs_after_arr_i_removed + " ");
    }
    return;
}
  
// Driver code
public static void main(String[] args)
{
     
    // Given Array
    int arr[] = { 2, 3, 4, 3, 2 };
    int N = arr.length;
  
    pairs_after_removing(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga

Python3




# python program to implement
# the above approach
 
# Function to count pairs of equal elements
# by removing arr[i] from the array
def pairs_after_removing(arr, N):
     
    # Stores total count of
    # pairs of equal elements
    cntPairs = 0
 
    # Store frequency of each
    # distinct array element
    mp = {}
 
    # Traverse the array
    for i in arr:
 
        # Update frequency of arr[i]
        mp[i] = mp.get(i, 0) + 1
 
    # Traverse the map
    for element in mp:
 
        # Stores key of an element
        i = element
        cntPairs += mp[i] * (mp[i] - 1) // 2
 
    # Traverse the array
    for i in range(N):
 
        # Stores count of pairs of equal
        # element by removing arr[i]
        pairs_after_arr_i_removed = cntPairs + 1 - mp[arr[i]]
 
        print(pairs_after_arr_i_removed, end = ' ')
    return
 
# Driver Code
if __name__ == '__main__':
   
    # Given Array
    arr = [2, 3, 4, 3, 2]
    N = len(arr)
    pairs_after_removing(arr, N)
 
# This code is contributed by mohit kumar 29

C#




// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
   
class GFG
{
   
// Function to count pairs of equal elements
// by removing arr[i] from the array
static void pairs_after_removing(int[] arr, int N)
{
      
    // Stores total count of
    // pairs of equal elements
    int cntPairs = 0;
   
    // Store frequency of each
    // distinct array element
     Dictionary<int,
            int> mp = new Dictionary<int,
                                      int>();
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
          
        // Update frequency of arr[i]
        if(mp.ContainsKey(arr[i]))
            {
                mp[arr[i]]++;
            }
            else
            {
                mp[arr[i]] = 1;
            }
    }
   
    // Traverse the map
    foreach(KeyValuePair<int,
                             int> element in mp)
    {
          
        // Stores key of an element
        int i = element.Key;
        cntPairs += mp[i] * (mp[i] - 1) / 2;
    }
   
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
          
        // Stores count of pairs of equal
        // element by removing arr[i]
        int pairs_after_arr_i_removed = cntPairs +
                           1 - mp[arr[i]];
   
        Console.Write(pairs_after_arr_i_removed + " ");
    }
    return;
}
   
// Driver code
public static void Main()
{
      
    // Given Array
    int[] arr = { 2, 3, 4, 3, 2 };
    int N = arr.Length;
   
    pairs_after_removing(arr, N);
}
}
 
// This code is contributed by sanjoy_62
Output: 
1 1 2 1 1

 

Time complexity: O(N)
Auxiliary space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :