# Minimize swaps required to maximize the count of elements replacing a greater element in an Array

• Last Updated : 17 May, 2021

Given an array A[], consisting of N elements, the task is to find the minimum number of swaps required such that array elements swapped to replace a higher element, in the original array, are maximized.

Examples:

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.

Input: A[] = {4, 3, 3, 2, 5}
Output:
Explanation:
Swap 1: {4, 3, 3, 2, 5} -> {5, 3, 3, 2, 4
Swap 2: {5, 3, 3, 2, 4} -> {3, 3, 5, 2, 4}
Swap 3: {3, 3, 5, 2, 4} -> {3, 3, 2, 5, 4}
Therefore, elements {4, 3, 2} occupies original position of a higher element after swapping
Input:. A[] = {6, 5, 4, 3, 2, 1}
Output: 5

Naive Approach: The simplest approach to solve the problem can be implemented as follows:

• Sort the array in ascending order.
• Initialize two variables, result, and index, to store the count and the index up to which it has been considered in the original array, respectively.
• Iterate over the array elements. For any element A[i], go to a value in the array which is greater than ai and increment the index variable accordingly.
• After finding an element greater than A[i], increment result, and index.
• If the index has reached the end of the array, no elements are left to be swapped with previously checked elements.
• Therefore, print count.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum``// number of swaps required``int` `countSwaps(``int` `A[], ``int` `n)``{``    ``// Sort the array in ascending order``    ``sort(A, A + n);` `    ``int` `ind = 1, res = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Iterate until a greater element``        ``// is found``        ``while` `(ind < n and A[ind] == A[i])` `            ``// Keep incrementing ind``            ``ind++;` `        ``// If a greater element is found``        ``if` `(ind < n and A[ind] > A[i]) {` `            ``// Increase count of swap``            ``res++;` `            ``// Increment ind``            ``ind++;``        ``}` `        ``// If end of array is reached``        ``if` `(ind >= n)``            ``break``;``    ``}` `    ``// Return the answer``    ``return` `res;``}` `// Driver Code``int` `main()``{` `    ``int` `A[] = { 4, 3, 3, 2, 5 };``    ``cout << countSwaps(A, 5);` `    ``return` `0;``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG{` `// Function to find the minimum``// number of swaps required``static` `int` `countSwaps(``int` `A[], ``int` `n)``{``    ``// Sort the array in ascending order``    ``Arrays.sort(A);``    ``int` `ind = ``1``, res = ``0``;` `    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Iterate until a greater element``        ``// is found``        ``while` `(ind < n && A[ind] == A[i])` `            ``// Keep incrementing ind``            ``ind++;` `        ``// If a greater element is found``        ``if` `(ind < n && A[ind] > A[i])``        ``{` `            ``// Increase count of swap``            ``res++;` `            ``// Increment ind``            ``ind++;``        ``}` `        ``// If end of array is reached``        ``if` `(ind >= n)``            ``break``;``    ``}` `    ``// Return the answer``    ``return` `res;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``4``, ``3``, ``3``, ``2``, ``5` `};``    ``System.out.print(countSwaps(A, ``5``));``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the minimum``# number of swaps required``def` `countSwaps(A, n):` `    ``# Sort the array in ascending order``    ``A.sort()` `    ``ind, res ``=` `1``, ``0` `    ``for` `i ``in` `range``(n):` `        ``# Iterate until a greater element``        ``# is found``        ``while` `(ind < n ``and` `A[ind] ``=``=` `A[i]):` `            ``# Keep incrementing ind``            ``ind ``+``=` `1` `        ``# If a greater element is found``        ``if` `(ind < n ``and` `A[ind] > A[i]):` `            ``# Increase count of swap``            ``res ``+``=` `1` `            ``# Increment ind``            ``ind ``+``=` `1` `        ``# If end of array is reached``        ``if` `(ind >``=` `n):``            ``break` `    ``# Return the answer``    ``return` `res` `# Driver Code``A ``=` `[ ``4``, ``3``, ``3``, ``2``, ``5` `]` `print` `(countSwaps(A, ``5``))` `# This code is contributed by chitranayal`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG{` `// Function to find the minimum``// number of swaps required``static` `int` `countSwaps(``int` `[]A, ``int` `n)``{``    ``// Sort the array in ascending order``    ``Array.Sort(A);``    ``int` `ind = 1, res = 0;` `    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// Iterate until a greater element``        ``// is found``        ``while` `(ind < n && A[ind] == A[i])` `            ``// Keep incrementing ind``            ``ind++;` `        ``// If a greater element is found``        ``if` `(ind < n && A[ind] > A[i])``        ``{` `            ``// Increase count of swap``            ``res++;` `            ``// Increment ind``            ``ind++;``        ``}` `        ``// If end of array is reached``        ``if` `(ind >= n)``            ``break``;``    ``}` `    ``// Return the answer``    ``return` `res;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]A = { 4, 3, 3, 2, 5 };``    ``Console.Write(countSwaps(A, 5));``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N * log N)
Auxiliary Space: O(1)

Efficient Approach:
Since any swap between two unequal elements leads to an element replacing a higher element, it can be observed that the minimum number of swaps required is N – (the maximum frequency of an array element). Therefore, find the most frequent element in the array using HashMap, and print the result.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum``// number of swaps required``int` `countSwaps(``int` `A[], ``int` `n)``{``    ``// Stores the frequency of the``    ``// array elements``    ``map<``int``, ``int``> mp;` `    ``// Stores maximum frequency``    ``int` `max_frequency = 0;` `    ``// Find the max frequency``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Update frequency``        ``mp[A[i]]++;` `        ``// Update maximum frequency``        ``max_frequency``            ``= max(max_frequency, mp[A[i]]);``    ``}` `    ``return` `n - max_frequency;``}` `// Driver Code``int` `main()``{` `    ``int` `A[] = { 6, 5, 4, 3, 2, 1 };` `    ``// function call``    ``cout << countSwaps(A, 6);` `    ``return` `0;``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG{` `// Function to find the minimum``// number of swaps required``static` `int` `countSwaps(``int` `arr[], ``int` `n)``{``    ``// Stores the frequency of the``    ``// array elements``    ``HashMap mp = ``new` `HashMap();` `    ``// Stores maximum frequency``    ``int` `max_frequency = ``0``;` `    ``// Find the max frequency``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// Update frequency``        ``if``(mp.containsKey(arr[i]))``        ``{``            ``mp.put(arr[i], mp.get(arr[i]) + ``1``);``        ``}``        ``else``        ``{``            ``mp.put(arr[i], ``1``);``        ``}` `        ``// Update maximum frequency``        ``max_frequency = Math.max(max_frequency,``                                 ``mp.get(arr[i]));``    ``}``    ``return` `n - max_frequency;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[] = { ``6``, ``5``, ``4``, ``3``, ``2``, ``1` `};` `    ``// function call``    ``System.out.print(countSwaps(A, ``6``));``}``}` `// This code is contributed by Rohit_ranjan`

## Python3

 `# Python3 Program to implement``# the above approach` `# Function to find the minimum``# number of swaps required``def` `countSwaps(A, n):``    ` `    ``# Stores the frequency of the``    ``# array elements``    ``mp ``=` `{}` `    ``# Stores maximum frequency``    ``max_frequency ``=` `0` `    ``# Find the max frequency``    ``for` `i ``in` `range``(n):` `        ``# Update frequency``        ``if` `A[i] ``in` `mp:``            ``mp[A[i]] ``+``=` `1``        ``else``:``            ``mp[A[i]] ``=` `1` `        ``# Update maximum frequency``        ``max_frequency ``=` `max``(max_frequency,``                            ``mp[A[i]])` `    ``return` `n ``-` `max_frequency``  ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:   ` `      ``A ``=` `[``6``, ``5``, ``4``, ``3``, ``2``, ``1``]``    ` `    ``# function call``    ``print``(countSwaps(A, ``6``))` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the minimum``// number of swaps required``static` `int` `countSwaps(``int` `[]arr, ``int` `n)``{``    ` `    ``// Stores the frequency of the``    ``// array elements``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();` `    ``// Stores maximum frequency``    ``int` `max_frequency = 0;` `    ``// Find the max frequency``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``// Update frequency``        ``if``(mp.ContainsKey(arr[i]))``        ``{``            ``mp[arr[i]] = mp[arr[i]] + 1;``        ``}``        ``else``        ``{``            ``mp.Add(arr[i], 1);``        ``}` `        ``// Update maximum frequency``        ``max_frequency = Math.Max(max_frequency,``                                 ``mp[arr[i]]);``    ``}``    ``return` `n - max_frequency;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]A = { 6, 5, 4, 3, 2, 1 };` `    ``// Function call``    ``Console.Write(countSwaps(A, 6));``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 `   `
Output:
`5`

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

My Personal Notes arrow_drop_up