Related Articles

# Count decrements to nearest smaller element required to make all array elements equal

• Difficulty Level : Medium
• Last Updated : 19 May, 2021

Given an array arr[] consisting of N non-negative integers, the task is to find the number of operations required to make all array elements equal. In each operation, any array element can be changed to its nearest smaller array element.

Examples:

Input: arr[] = {2, 5, 4, 3, 5, 4}
Output: 11
Explanation:
Step 1: Replace all 5s with 4s. Therefore, arr[] = {2, 4, 4, 3, 4, 4}. Count of operations = 2
Step 2: Replace all 4s with 3s. Therefore, arr[] = {2, 3, 3, 3, 3, 3}. Count of operations = 4
Steps 3: Replace all 3s with 2s. Therefore, arr[] = {2, 2, 2, 2, 2, 2}. Count of operations = 5
Therefore, total number of operations = 11

Input : arr[] = {2, 2, 2}
Output : 0

Approach: The idea is to use a sorting algorithm and a Map data structure. Follow the steps below to solve the problem:

1. Initialize a Map to store the frequency of each array element except for the minimum element where keys (K) are the set of unique elements and values (V) are their frequencies.
2. Sort the Map in decreasing order based on the keys.
3. Initialize two variables ans and prev_val with 0 to store the current answer and the prefix sum respectively.
4. Now iterate the Map and add the corresponding frequencies of each element along with prev_val to ans as ans = ans + (freq) + prev_val
5. While iterating the Map, increment prev_val every time by the frequency of the current element.
6. After traversing the Map completely, print ans as the minimum number of operations.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to print the minimum number of``// decrements to make all elements equals``int` `MinimumNoOfOperations(``int` `arr[], ``int` `n)``{` `    ``// Find minimum element``    ``int` `min_ele = INT_MAX;``    ``for` `(``int` `i = 0; i < n; ++i) {``        ``min_ele = min(min_ele, arr[i]);``    ``}` `    ``// Stores frequencies of array elements``    ``map<``int``, ``int``, greater<``int``> > mp;` `    ``// Update frequencies in the Map``    ``for` `(``int` `i = 0; i < n; ++i) {` `        ``if` `(arr[i] == min_ele)``            ``continue``;``        ``else``            ``mp[arr[i]]++;``    ``}` `    ``// Iterate the map``    ``map<``int``, ``int``>::iterator it;` `    ``// Stores the count of``    ``// decrements at each iteration``    ``int` `prev_val = 0;` `    ``// Stores the total``    ``// count of derements``    ``int` `ans = 0;` `    ``// Calculate the number of decrements``    ``for` `(it = mp.begin(); it != mp.end();``         ``++it) {` `        ``ans += (it->second + prev_val);``        ``prev_val += it->second;``    ``}` `    ``// Return minimum operations``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 5, 4, 3, 5, 4 };` `    ``// Given size``    ``int` `size = ``sizeof``(arr)``               ``/ ``sizeof``(arr);` `    ``// Function call``    ``cout << MinimumNoOfOperations(``        ``arr, size);``    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;` `class` `solution{``   ` `// Function to print the minimum``// number of decrements to make``// all elements equals``static` `int` `MinimumNoOfOperations(``int` `arr[],``                                 ``int` `n)``{``  ``// Find minimum element``  ``int` `min_ele = Integer.MAX_VALUE;``  ` `  ``for` `(``int` `i = ``0``; i < n; ++i)``  ``{``    ``min_ele = Math.min(min_ele,``                       ``arr[i]);``  ``}` `  ``// Stores frequencies of array``  ``// elements``  ``TreeMap mp =``          ``new` `TreeMap(``          ``Collections.reverseOrder());` `  ``// Update frequencies in``  ``// the Map``  ``for` `(``int` `i = ``0``; i < n; ++i)``  ``{``    ``if` `(arr[i] == min_ele)``      ``continue``;``    ``else``      ``mp.put(arr[i],``      ``mp.getOrDefault(arr[i], ``0``) + ``1``);``  ``}` `  ``// Stores the count of``  ``// decrements at each``  ``// iteration``  ``int` `prev_val = ``0``;` `  ``// Stores the total``  ``// count of derements``  ``int` `ans = ``0``;` `  ``// Calculate the number of``  ``// decrements``  ``for` `(Map.Entry it : mp.entrySet())``  ``{``    ``ans += (it.getValue() + prev_val);``    ``prev_val += it.getValue();``  ``}` `  ``// Return minimum operations``  ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``  ``// Given array``  ``int` `arr[] = {``2``, ``5``, ``4``, ``3``, ``5``, ``4``};``  ` `  ``// Given size``  ``int` `size = arr.length;``  ` `  ``// Function call``  ``System.out.println(``  ``MinimumNoOfOperations(arr, size));``}``}` `// This code is contributed by bgangwar59`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to print the minimum number of``# decrements to make all elements equals``def` `MinimumNoOfOperations(arr, n):``    ` `    ``# Find minimum element``    ``min_ele ``=` `sys.maxsize``    ` `    ``for` `i ``in` `range``(n):``        ``min_ele ``=` `min``(min_ele, arr[i])` `    ``# Stores frequencies of array elements``    ``mp ``=` `{}` `    ``# Update frequencies in the Map``    ``for` `i ``in` `range``(n):``        ``if` `(arr[i] ``=``=` `min_ele):``            ``continue``        ``else``:``            ``mp[arr[i]] ``=` `mp.get(arr[i], ``0``) ``+` `1``            ` `    ``# Stores the count of``    ``# decrements at each iteration``    ``prev_val ``=` `0` `    ``# Stores the total``    ``# count of derements``    ``ans ``=` `0` `    ``# Calculate the number of decrements``    ``for` `it ``in` `mp:``        ``ans ``+``=` `(mp[it] ``+` `prev_val)``        ``prev_val ``+``=` `mp[it]` `    ``# Return minimum operations``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given array``    ``arr ``=` `[ ``2``, ``5``, ``4``, ``3``, ``5``, ``4` `]` `    ``# Given size``    ``size ``=` `len``(arr)` `    ``# Function call``    ``print``(MinimumNoOfOperations(arr, size))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System.Collections.Generic;``using` `System;``using` `System.Linq;` `class` `GFG{``   ` `// Function to print the minimum``// number of decrements to make``// all elements equals``static` `int` `MinimumNoOfOperations(``int` `[]arr,``                                 ``int` `n)``{``  ` `  ``// Find minimum element``  ``int` `min_ele = 1000000000;``  ` `  ``for``(``int` `i = 0; i < n; ++i)``  ``{``      ``min_ele = Math.Min(min_ele, arr[i]);``  ``}` `  ``// Stores frequencies of array``  ``// elements``  ``Dictionary<``int``,``             ``int``> mp = ``new` `Dictionary<``int``,``                                      ``int``>();` `  ``// Update frequencies in``  ``// the Map``  ``for``(``int` `i = 0; i < n; ++i)``  ``{``    ``if` `(arr[i] == min_ele)``      ``continue``;``    ``else``    ``{``      ``if` `(mp.ContainsKey(arr[i]) == ``true``)``        ``mp[arr[i]] += 1;``      ``else``        ``mp[arr[i]] = 1;   ``    ``}``  ``}` `  ``// Stores the count of``  ``// decrements at each``  ``// iteration``  ``int` `prev_val = 0;` `  ``// Stores the total``  ``// count of derements``  ``int` `ans = 0;` `  ``// Calculate the number of``  ``// decrements``  ``var` `val = mp.Keys.ToList();``  ``foreach``(``var` `key ``in` `val)``  ``{``    ``ans += (mp[key] + prev_val);``    ``prev_val += mp[key];``  ``}``  ` `  ``// Return minimum operations``  ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ` `  ``// Given array``  ``int` `[]arr = { 2, 5, 4, 3, 5, 4 };``  ` `  ``// Given size``  ``int` `size = arr.Length;``  ` `  ``// Function call``  ``Console.WriteLine(MinimumNoOfOperations(``    ``arr, size));``}``}` `// This code is contributed by Stream_Cipher`

## Javascript

 ``
Output:
`11`

Time Complexity: O(N) where N is the size of the array.
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up