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

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, is maximized.

Examples:

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}
OutputL 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, repectively.
• Iterate over the array elements. For any element A[i], go to a value in the array which is greater than ai and increment index variable accordingly.
• After finding an element greater than A[i], increment result and index.
• If 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`

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`

## 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 `

Output:

```5
```

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 Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.